void StegoModel::doMMDs() {
map< pair< int, int >, FeatureCollection* >::iterator fiter;
FeatureCollection::Iterator *citer;
// featureSet *stego;
mc = (mmdContext*) malloc(sizeof(mmdContext));
mc->clean = cleanSet;
startAction(mc->clean);
initMMD(steg, *mc);
estimateGamma(steg, *mc);
// mc->stego = mc->clean;
// estimateMMD(steg, *mc);
for (fiter = collections.begin(); fiter != collections.end(); fiter++) {
if (fiter->second != 0) {
printf("<%i, %i> \n", fiter->first.first, fiter->first.second);
citer = fiter->second->iterator();
while (citer->hasNext()) {
mc->stego = citer->next();
printf("doing set %g \n", mc->stego->header->prob);
startAction(mc->stego);
estimateMMD(steg, *mc);
mc->stego->mmd = mc->mmd;
endAction(mc->stego);
}
}
}
endAction(mc->clean);
closeMMD(*mc);
}
void StegoModel::estimateMus() {
map< pair< int, int >, FeatureCollection* >::iterator fiter;
FeatureCollection::Iterator *citer;
// featureSet *stego;
steg->features = cleanSet;
// printf("activating something \n");
startAction(steg->features);
// printf("estimating some mu... \n");
estimateMu(steg);
// printf("done \n");
// estimateSigma(steg);
// qrHouseholder(steg);
endAction(steg->features);
for (fiter = collections.begin(); fiter != collections.end(); fiter++) {
if (fiter->second != 0) {
// printf("<%i, %i> \n", fiter->first.first, fiter->first.second);
citer = fiter->second->iterator();
while (citer->hasNext()) {
steg->features = citer->next();
// printf("About to estimate mu with dim=%i, M=%i \n", steg->features->dim, steg->features->M);
startAction(steg->features);
estimateMu(steg);
endAction(steg->features);
// progressChanged((double) i / (double) j);
}
}
}
steg->features = cleanSet;
modelChanged();
}
void KisSelectionToVectorActionFactory::run(KisView2 *view)
{
KisSelectionSP selection = view->selection();
if (selection->hasShapeSelection() ||
!selection->outlineCacheValid()) {
return;
}
QPainterPath selectionOutline = selection->outlineCache();
QTransform transform = view->canvasBase()->coordinatesConverter()->imageToDocumentTransform();
KoShape *shape = KoPathShape::createShapeFromPainterPath(transform.map(selectionOutline));
shape->setShapeId(KoPathShapeId);
/**
* Mark a shape that it belongs to a shape selection
*/
if(!shape->userData()) {
shape->setUserData(new KisShapeSelectionMarker);
}
KisProcessingApplicator *ap = beginAction(view, i18n("Convert to Vector Selection"));
ap->applyCommand(view->canvasBase()->shapeController()->addShape(shape),
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::EXCLUSIVE);
endAction(ap, KisOperationConfiguration(id()).toXML());
}
void KisSelectAllActionFactory::run(KisView2 *view)
{
KisProcessingApplicator *ap = beginAction(view, i18n("Select All"));
KisImageWSP image = view->image();
if (!image->globalSelection()) {
ap->applyCommand(new KisSetEmptyGlobalSelectionCommand(image),
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::EXCLUSIVE);
}
struct SelectAll : public KisTransactionBasedCommand {
SelectAll(KisImageSP image) : m_image(image) {}
KisImageSP m_image;
KUndo2Command* paint() {
KisSelectionSP selection = m_image->globalSelection();
KisSelectionTransaction transaction(QString(), m_image->undoAdapter(), selection);
selection->getOrCreatePixelSelection()->select(m_image->bounds());
return transaction.endAndTake();
}
};
ap->applyCommand(new SelectAll(image),
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::EXCLUSIVE);
endAction(ap, KisOperationConfiguration(id()).toXML());
}
void KisCutCopyActionFactory::run(bool willCut, KisView2 *view)
{
KisImageSP image = view->image();
bool haveShapesSelected = view->selectionManager()->haveShapesSelected();
if (haveShapesSelected) {
#ifdef __GNUC__
#warning "Add saving of XML data for Cut/Copy of shapes"
#endif
image->barrierLock();
if (willCut) {
view->canvasBase()->toolProxy()->cut();
} else {
view->canvasBase()->toolProxy()->copy();
}
image->unlock();
} else {
KisNodeSP node = view->activeNode();
if (!node) return;
image->barrierLock();
ActionHelper::copyFromDevice(view, node->paintDevice());
image->unlock();
KUndo2Command *command = 0;
if (willCut && node->isEditable()) {
struct ClearSelection : public KisTransactionBasedCommand {
ClearSelection(KisNodeSP node, KisSelectionSP sel)
: m_node(node), m_sel(sel) {}
KisNodeSP m_node;
KisSelectionSP m_sel;
KUndo2Command* paint() {
KisTransaction transaction("", m_node->paintDevice());
m_node->paintDevice()->clearSelection(m_sel);
m_node->setDirty(m_sel->selectedRect());
return transaction.endAndTake();
}
};
command = new ClearSelection(node, view->selection());
}
QString actionName = willCut ? i18n("Cut") : i18n("Copy");
KisProcessingApplicator *ap = beginAction(view, actionName);
if (command) {
ap->applyCommand(command,
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::NORMAL);
}
KisOperationConfiguration config(id());
config.setProperty("will-cut", willCut);
endAction(ap, config.toXML());
}
}
//====================================================================================
void CActionHistoric::newPendingAction(const ucstring &name)
{
//H_AUTO(R2_CActionHistoric_newPendingAction)
endAction();
_NewActionIsPending = true;
_NewActionName = name;
getEditor().callEnvMethod("onPendingActionBegin", 0, 0);
}
void KisReselectActionFactory::run(KisView2 *view)
{
KUndo2Command *cmd = new KisReselectGlobalSelectionCommand(view->image());
KisProcessingApplicator *ap = beginAction(view, cmd->text());
ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
endAction(ap, KisOperationConfiguration(id()).toXML());
}
virtual void algorithm(unsigned long count) {
beginAction(1, "gauss", count, comment<PRECISION>().c_str());
for (unsigned long i = 0; i < count; ++i) {
PRECISION n = gaussianRandBoxMuller(3, 6);
n = n;
}
endAction();
}
//====================================================================================
void CActionHistoric::newMultiAction(const ucstring &name, uint actionCount)
{
//H_AUTO(R2_CActionHistoric_newMultiAction)
_SubActionCount = 1; // force previous multi action to finish
endAction();
_NewActionIsPending = false;
_SubActionCount = actionCount;
_NewActionName = name;
}
//====================================================================================
void CActionHistoric::forceEndMultiAction()
{
//H_AUTO(R2_CActionHistoric_forceEndMultiAction)
if (_NewActionIsPending && _NewAction)
{
_NewAction->flush(_DMC, _Scenario);
}
if (_SubActionCount > 1) _SubActionCount = 1;
endAction();
}
//====================================================================================
void CActionHistoric::newPendingMultiAction(const ucstring &name, uint actionCount)
{
//H_AUTO(R2_CActionHistoric_newPendingMultiAction)
_SubActionCount = 1; // force previous multi action to finish
endAction();
_NewActionIsPending = true;
_SubActionCount = actionCount;
_NewActionName = name;
getEditor().callEnvMethod("onPendingActionBegin", 0, 0);
}
void KisCopyMergedActionFactory::run(KisView2 *view)
{
KisImageWSP image = view->image();
image->barrierLock();
KisPaintDeviceSP dev = image->root()->projection();
ActionHelper::copyFromDevice(view, dev);
image->unlock();
KisProcessingApplicator *ap = beginAction(view, i18n("Copy Merged"));
endAction(ap, KisOperationConfiguration(id()).toXML());
}
//====================================================================================
void CActionHistoric::newSingleAction(const ucstring &name)
{
//H_AUTO(R2_CActionHistoric_newSingleAction)
endAction();
if (_SubActionCount == 0)
{
_SubActionCount = 1;
_NewActionIsPending = false;
}
if (!_NewActionIsPending)
{
_NewActionName = name;
}
}
void KisPasteActionFactory::run(KisView2 *view)
{
KisImageWSP image = view->image();
//figure out where to position the clip
// XXX: Fix this for internal points & zoom! (BSAR)
QWidget * w = view->canvas();
QPoint center = QPoint(w->width() / 2, w->height() / 2);
QPoint bottomright = QPoint(w->width(), w->height());
if (bottomright.x() > image->width())
center.setX(image->width() / 2);
if (bottomright.y() > image->height())
center.setY(image->height() / 2);
const KoCanvasBase* canvasBase = view->canvasBase();
const KoViewConverter* viewConverter = view->canvasBase()->viewConverter();
KisPaintDeviceSP clip = KisClipboard::instance()->clip(
QPoint(
viewConverter->viewToDocumentX(canvasBase->canvasController()->canvasOffsetX()) + center.x(),
viewConverter->viewToDocumentY(canvasBase->canvasController()->canvasOffsetY()) + center.y()));
if (clip) {
// Pasted layer content could be outside image bounds and invisible, if that is the case move content into the bounds
QRect exactBounds = clip->exactBounds();
if (!exactBounds.isEmpty() && !exactBounds.intersects(image->bounds())) {
clip->setX(clip->x() - exactBounds.x());
clip->setY(clip->y() - exactBounds.y());
}
KisPaintLayer *newLayer = new KisPaintLayer(image.data(), image->nextLayerName() + i18n("(pasted)"), OPACITY_OPAQUE_U8, clip);
KisNodeSP aboveNode = view->activeLayer();
KisNodeSP parentNode = aboveNode ? aboveNode->parent() : image->root();
KUndo2Command *cmd = new KisImageLayerAddCommand(image, newLayer, parentNode, aboveNode);
KisProcessingApplicator *ap = beginAction(view, cmd->text());
ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
endAction(ap, KisOperationConfiguration(id()).toXML());
} else {
#ifdef __GNUC__
#warning "Add saving of XML data for Paste of shapes"
#endif
view->canvasBase()->toolProxy()->paste();
}
}
void KisPasteActionFactory::run(KisViewManager *view)
{
KisImageWSP image = view->image();
if (!image) return;
KisPaintDeviceSP clip = KisClipboard::instance()->clip(image->bounds(), true);
if (clip) {
KisPaintLayer *newLayer = new KisPaintLayer(image.data(), image->nextLayerName() + i18n("(pasted)"), OPACITY_OPAQUE_U8, clip);
KisNodeSP aboveNode = view->activeLayer();
KisNodeSP parentNode = aboveNode ? aboveNode->parent() : image->root();
KUndo2Command *cmd = new KisImageLayerAddCommand(image, newLayer, parentNode, aboveNode);
KisProcessingApplicator *ap = beginAction(view, cmd->text());
ap->applyCommand(cmd, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
endAction(ap, KisOperationConfiguration(id()).toXML());
} else {
// XXX: "Add saving of XML data for Paste of shapes"
view->canvasBase()->toolProxy()->paste();
}
}
void test(long items) {
long count = getCountWithDefault(items);
std::cout << "*** Testing thread creation performance"
<< std::endl;
beginAction(1, "thread creation", count);
reset();
ThreadCreationPerformance* performance =
new ThreadCreationPerformance();
for (long i = 0; i < count; ++i) {
try {
Thread* thread = new Thread(performance);
thread->start();
thread->join();
delete thread;
proceed();
} catch (ThreadException& te) {
std::cerr << "Exception: " << te.message() << std::endl;
}
}
delete performance;
reset();
endAction();
}
void KisCutCopyActionFactory::run(bool willCut, bool makeSharpClip, KisViewManager *view)
{
KisImageSP image = view->image();
if (!image) return;
bool haveShapesSelected = view->selectionManager()->haveShapesSelected();
if (haveShapesSelected) {
// XXX: "Add saving of XML data for Cut/Copy of shapes"
KisImageBarrierLocker locker(image);
if (willCut) {
view->canvasBase()->toolProxy()->cut();
} else {
view->canvasBase()->toolProxy()->copy();
}
} else {
KisNodeSP node = view->activeNode();
if (!node) return;
KisSelectionSP selection = view->selection();
if (selection.isNull()) return;
{
KisImageBarrierLocker locker(image);
KisPaintDeviceSP dev = node->paintDevice();
if (!dev) {
dev = node->projection();
}
if (!dev) {
view->showFloatingMessage(
i18nc("floating message when cannot copy from a node",
"Cannot copy pixels from this type of layer "),
QIcon(), 3000, KisFloatingMessage::Medium);
return;
}
if (dev->exactBounds().isEmpty()) {
view->showFloatingMessage(
i18nc("floating message when copying empty selection",
"Selection is empty: no pixels were copied "),
QIcon(), 3000, KisFloatingMessage::Medium);
return;
}
ActionHelper::copyFromDevice(view, dev, makeSharpClip);
}
if (willCut) {
KUndo2Command *command = 0;
if (willCut && node->hasEditablePaintDevice()) {
struct ClearSelection : public KisTransactionBasedCommand {
ClearSelection(KisNodeSP node, KisSelectionSP sel)
: m_node(node), m_sel(sel) {}
KisNodeSP m_node;
KisSelectionSP m_sel;
KUndo2Command* paint() {
KisSelectionSP cutSelection = m_sel;
// Shrinking the cutting area was previously used
// for getting seamless cut-paste. Now we use makeSharpClip
// instead.
// QRect originalRect = cutSelection->selectedExactRect();
// static const int preciseSelectionThreshold = 16;
//
// if (originalRect.width() > preciseSelectionThreshold ||
// originalRect.height() > preciseSelectionThreshold) {
// cutSelection = new KisSelection(*m_sel);
// delete cutSelection->flatten();
//
// KisSelectionFilter* filter = new KisShrinkSelectionFilter(1, 1, false);
//
// QRect processingRect = filter->changeRect(originalRect);
// filter->process(cutSelection->pixelSelection(), processingRect);
// }
KisTransaction transaction(m_node->paintDevice());
m_node->paintDevice()->clearSelection(cutSelection);
m_node->setDirty(cutSelection->selectedRect());
return transaction.endAndTake();
}
};
command = new ClearSelection(node, selection);
}
KUndo2MagicString actionName = willCut ?
kundo2_i18n("Cut") :
kundo2_i18n("Copy");
KisProcessingApplicator *ap = beginAction(view, actionName);
if (command) {
ap->applyCommand(command,
KisStrokeJobData::SEQUENTIAL,
KisStrokeJobData::NORMAL);
}
KisOperationConfiguration config(id());
config.setProperty("will-cut", willCut);
endAction(ap, config.toXML());
}
}
}
void KisFillActionFactory::run(const QString &fillSource, KisView2 *view)
{
KisNodeSP node = view->activeNode();
if (!node || !node->isEditable()) return;
KisSelectionSP selection = view->selection();
QRect selectedRect = selection ?
selection->selectedRect() : view->image()->bounds();
KisPaintDeviceSP filled = node->paintDevice()->createCompositionSourceDevice();
QString actionName;
if (fillSource == "pattern") {
KisFillPainter painter(filled);
painter.fillRect(selectedRect.x(), selectedRect.y(),
selectedRect.width(), selectedRect.height(),
view->resourceProvider()->currentPattern());
painter.end();
actionName = i18n("Fill with Pattern");
} else if (fillSource == "bg") {
KoColor color(filled->colorSpace());
color.fromKoColor(view->resourceProvider()->bgColor());
filled->setDefaultPixel(color.data());
actionName = i18n("Fill with Background Color");
} else if (fillSource == "fg") {
KoColor color(filled->colorSpace());
color.fromKoColor(view->resourceProvider()->fgColor());
filled->setDefaultPixel(color.data());
actionName = i18n("Fill with Foreground Color");
}
struct BitBlt : public KisTransactionBasedCommand {
BitBlt(KisPaintDeviceSP src, KisPaintDeviceSP dst,
KisSelectionSP sel, const QRect &rc)
: m_src(src), m_dst(dst), m_sel(sel), m_rc(rc){}
KisPaintDeviceSP m_src;
KisPaintDeviceSP m_dst;
KisSelectionSP m_sel;
QRect m_rc;
KUndo2Command* paint() {
KisPainter gc(m_dst, m_sel);
gc.beginTransaction("");
gc.bitBlt(m_rc.x(), m_rc.y(),
m_src,
m_rc.x(), m_rc.y(),
m_rc.width(), m_rc.height());
m_dst->setDirty(m_rc);
return gc.endAndTakeTransaction();
}
};
KisProcessingApplicator *ap = beginAction(view, actionName);
ap->applyCommand(new BitBlt(filled, view->activeDevice()/*node->paintDevice()*/, selection, selectedRect),
KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::NORMAL);
KisOperationConfiguration config(id());
config.setProperty("fill-source", fillSource);
endAction(ap, config.toXML());
}
