/**
* Constructor.
*/
RS_ActionPARISDebugCreateContainer::RS_ActionPARISDebugCreateContainer(
RS_EntityContainer& container,
RS_GraphicView& graphicView)
: RS_ActionInterface("rs_actionparischeckcont",
container, graphicView) {
//QMessageBox::about(NULL, "info", "check container");
RS_Document* theDoc = (RS_Document*) &container;
if (theDoc->countSelected() < 2) {
return;
}
RS_EntityContainer* con = new RS_EntityContainer(theDoc, true);
RS_PtrListIterator<RS_Entity> it = theDoc->createIterator();
RS_Entity* e;
while ( (e = it.current()) != 0) {
++it;
if (e->isSelected()) {
con->addEntity(e);
e->setParent(con);
}
}
theDoc -> addEntity(con);
}
void QG_GraphicView::layerActivated(RS_Layer *layer) {
RS_SETTINGS->beginGroup("/Modify");
bool toActivated= (RS_SETTINGS->readNumEntry("/ModifyEntitiesToActiveLayer", 0)==1);
RS_SETTINGS->endGroup();
if(!toActivated) return;
RS_EntityContainer *container = this->getContainer();
RS_Graphic* graphic = this->getGraphic();
QList<RS_Entity*> clones;
if (graphic) {
graphic->startUndoCycle();
}
for (auto en: *container) {
if (!en) continue;
if (!en->isSelected()) continue;
RS_Entity* cl = en->clone();
cl->setLayer(layer);
this->deleteEntity(en);
en->setSelected(false);
cl->setSelected(false);
clones << cl;
if (!graphic) continue;
en->setUndoState(true);
graphic->addUndoable(en);
}
for (auto cl: clones) {
container->addEntity(cl);
this->drawEntity(cl);
if (!graphic) continue;
graphic->addUndoable(cl);
}
if (graphic) {
graphic->endUndoCycle();
graphic->updateInserts();
}
container->calculateBorders();
container->setSelected(false);
redraw(RS2::RedrawDrawing);
}
/**
* Updates the Hatch. Called when the
* hatch or it's data, position, alignment, .. changes.
*/
void RS_Hatch::update() {
RS_DEBUG->print("RS_Hatch::update");
RS_DEBUG->print("RS_Hatch::update: contour has %d loops", count());
updateError = HATCH_OK;
if (updateRunning) {
return;
}
if (updateEnabled==false) {
return;
}
if (data.solid==true) {
calculateBorders();
return;
}
RS_DEBUG->print("RS_Hatch::update");
updateRunning = true;
// delete old hatch:
if (hatch) {
removeEntity(hatch);
hatch = nullptr;
}
if (isUndone()) {
updateRunning = false;
return;
}
if (!validate()) {
RS_DEBUG->print(RS_Debug::D_WARNING,
"RS_Hatch::update: invalid contour in hatch found");
updateRunning = false;
updateError = HATCH_INVALID_CONTOUR;
return;
}
// search pattern:
RS_DEBUG->print("RS_Hatch::update: requesting pattern");
RS_Pattern* pat = RS_PATTERNLIST->requestPattern(data.pattern);
if (!pat) {
updateRunning = false;
RS_DEBUG->print("RS_Hatch::update: requesting pattern: not found");
updateError = HATCH_PATTERN_NOT_FOUND;
return;
}
RS_DEBUG->print("RS_Hatch::update: requesting pattern: OK");
RS_DEBUG->print("RS_Hatch::update: cloning pattern");
pat = (RS_Pattern*)pat->clone();
RS_DEBUG->print("RS_Hatch::update: cloning pattern: OK");
// scale pattern
RS_DEBUG->print("RS_Hatch::update: scaling pattern");
pat->scale(RS_Vector(0.0,0.0), RS_Vector(data.scale, data.scale));
pat->calculateBorders();
forcedCalculateBorders();
RS_DEBUG->print("RS_Hatch::update: scaling pattern: OK");
// find out how many pattern-instances we need in x/y:
int px1, py1, px2, py2;
double f;
RS_Hatch* copy = (RS_Hatch*)this->clone();
copy->rotate(RS_Vector(0.0,0.0), -data.angle);
copy->forcedCalculateBorders();
// create a pattern over the whole contour.
RS_Vector pSize = pat->getSize();
RS_Vector rot_center=pat->getMin();
// RS_Vector cPos = getMin();
RS_Vector cSize = getSize();
RS_DEBUG->print("RS_Hatch::update: pattern size: %f/%f", pSize.x, pSize.y);
RS_DEBUG->print("RS_Hatch::update: contour size: %f/%f", cSize.x, cSize.y);
if (cSize.x<1.0e-6 || cSize.y<1.0e-6 ||
pSize.x<1.0e-6 || pSize.y<1.0e-6 ||
cSize.x>RS_MAXDOUBLE-1 || cSize.y>RS_MAXDOUBLE-1 ||
pSize.x>RS_MAXDOUBLE-1 || pSize.y>RS_MAXDOUBLE-1) {
delete pat;
delete copy;
updateRunning = false;
RS_DEBUG->print("RS_Hatch::update: contour size or pattern size too small");
updateError = HATCH_TOO_SMALL;
return;
}
// avoid huge memory consumption:
else if ( cSize.x* cSize.y/(pSize.x*pSize.y)>1e4) {
RS_DEBUG->print("RS_Hatch::update: contour size too large or pattern size too small");
delete pat;
delete copy;
updateError = HATCH_AREA_TOO_BIG;
return;
}
f = copy->getMin().x/pSize.x;
px1 = (int)floor(f);
f = copy->getMin().y/pSize.y;
py1 = (int)floor(f);
f = copy->getMax().x/pSize.x;
px2 = (int)ceil(f);
f = copy->getMax().y/pSize.y;
py2 = (int)ceil(f);
RS_Vector dvx=RS_Vector(data.angle)*pSize.x;
RS_Vector dvy=RS_Vector(data.angle+M_PI*0.5)*pSize.y;
pat->rotate(rot_center, data.angle);
pat->move(-rot_center);
RS_EntityContainer tmp; // container for untrimmed lines
// adding array of patterns to tmp:
RS_DEBUG->print("RS_Hatch::update: creating pattern carpet");
for (int px=px1; px<px2; px++) {
for (int py=py1; py<py2; py++) {
for(auto e: *pat){
RS_Entity* te=e->clone();
te->move(dvx*px + dvy*py);
tmp.addEntity(te);
}
}
}
delete pat;
pat = nullptr;
delete copy;
copy = nullptr;
RS_DEBUG->print("RS_Hatch::update: creating pattern carpet: OK");
RS_DEBUG->print("RS_Hatch::update: cutting pattern carpet");
// cut pattern to contour shape:
RS_EntityContainer tmp2; // container for small cut lines
RS_Line* line = nullptr;
RS_Arc* arc = nullptr;
RS_Circle* circle = nullptr;
RS_Ellipse* ellipse = nullptr;
for(auto e: tmp){
line = nullptr;
arc = nullptr;
circle = nullptr;
ellipse = nullptr;
RS_Vector startPoint;
RS_Vector endPoint;
RS_Vector center = RS_Vector(false);
bool reversed=false;
switch(e->rtti()){
case RS2::EntityLine:
line=static_cast<RS_Line*>(e);
startPoint = line->getStartpoint();
endPoint = line->getEndpoint();
break;
case RS2::EntityArc:
arc=static_cast<RS_Arc*>(e);
startPoint = arc->getStartpoint();
endPoint = arc->getEndpoint();
center = arc->getCenter();
reversed = arc->isReversed();
break;
case RS2::EntityCircle:
circle=static_cast<RS_Circle*>(e);
startPoint = circle->getCenter()
+ RS_Vector(circle->getRadius(), 0.0);
endPoint = startPoint;
center = circle->getCenter();
break;
case RS2::EntityEllipse:
ellipse = static_cast<RS_Ellipse*>(e);
startPoint = ellipse->getStartpoint();
endPoint = ellipse->getEndpoint();
center = ellipse->getCenter();
reversed = ellipse->isReversed();
break;
default:
continue;
}
// getting all intersections of this pattern line with the contour:
QList<std::shared_ptr<RS_Vector> > is;
for(auto loop: entities){
if (loop->isContainer()) {
for(auto p: * static_cast<RS_EntityContainer*>(loop)){
RS_VectorSolutions sol =
RS_Information::getIntersection(e, p, true);
for (const RS_Vector& vp: sol){
if (vp.valid) {
is.append(std::shared_ptr<RS_Vector>(
new RS_Vector(vp)
));
RS_DEBUG->print(" pattern line intersection: %f/%f",
vp.x, vp.y);
}
}
}
}
}
QList<std::shared_ptr<RS_Vector> > is2;//to be filled with sorted intersections
is2.append(std::shared_ptr<RS_Vector>(new RS_Vector(startPoint)));
// sort the intersection points into is2 (only if there are intersections):
if(is.size() == 1)
{//only one intersection
is2.append(is.first());
}
else if(is.size() > 1)
{
RS_Vector sp = startPoint;
double sa = center.angleTo(sp);
if(ellipse ) sa=ellipse->getEllipseAngle(sp);
bool done;
double minDist;
double dist = 0.0;
std::shared_ptr<RS_Vector> av;
std::shared_ptr<RS_Vector> v;
RS_Vector last = RS_Vector(false);
do {
done = true;
minDist = RS_MAXDOUBLE;
av.reset();
for (int i = 0; i < is.size(); ++i) {
v = is.at(i);
double a;
switch(e->rtti()){
case RS2::EntityLine:
dist = sp.distanceTo(*v);
break;
case RS2::EntityArc:
case RS2::EntityCircle:
a = center.angleTo(*v);
dist = reversed?
fmod(sa - a + 2.*M_PI,2.*M_PI):
fmod(a - sa + 2.*M_PI,2.*M_PI);
break;
case RS2::EntityEllipse:
a = ellipse->getEllipseAngle(*v);
dist = reversed?
fmod(sa - a + 2.*M_PI,2.*M_PI):
fmod(a - sa + 2.*M_PI,2.*M_PI);
break;
default:
break;
}
if (dist<minDist) {
minDist = dist;
done = false;
av = v;
}
}
// copy to sorted list, removing double points
if (!done && av.get()) {
if (last.valid==false || last.distanceTo(*av)>RS_TOLERANCE) {
is2.append(std::shared_ptr<RS_Vector>(new RS_Vector(*av)));
last = *av;
}
#if QT_VERSION < 0x040400
emu_qt44_removeOne(is, av);
#else
is.removeOne(av);
#endif
av.reset();
}
} while(!done);
}
is2.append(std::shared_ptr<RS_Vector>(new RS_Vector(endPoint)));
// add small cut lines / arcs to tmp2:
for (int i = 1; i < is2.size(); ++i) {
auto v1 = is2.at(i-1);
auto v2 = is2.at(i);
if (line) {
tmp2.addEntity(new RS_Line{&tmp2, *v1, *v2});
} else if (arc || circle) {
if(fabs(center.angleTo(*v2)-center.angleTo(*v1)) > RS_TOLERANCE_ANGLE)
{//don't create an arc with a too small angle
tmp2.addEntity(new RS_Arc(&tmp2,
RS_ArcData(center,
center.distanceTo(*v1),
center.angleTo(*v1),
center.angleTo(*v2),
reversed)));
}
}
}
}
// updating hatch / adding entities that are inside
RS_DEBUG->print("RS_Hatch::update: cutting pattern carpet: OK");
//RS_EntityContainer* rubbish = new RS_EntityContainer(getGraphic());
// the hatch pattern entities:
hatch = new RS_EntityContainer(this);
hatch->setPen(RS_Pen(RS2::FlagInvalid));
hatch->setLayer(nullptr);
hatch->setFlag(RS2::FlagTemp);
//calculateBorders();
for(auto e: tmp2){
RS_Vector middlePoint;
RS_Vector middlePoint2;
if (e->rtti()==RS2::EntityLine) {
RS_Line* line = static_cast<RS_Line*>(e);
middlePoint = line->getMiddlePoint();
middlePoint2 = line->getNearestDist(line->getLength()/2.1,
line->getStartpoint());
} else if (e->rtti()==RS2::EntityArc) {
RS_Arc* arc = static_cast<RS_Arc*>(e);
middlePoint = arc->getMiddlePoint();
middlePoint2 = arc->getNearestDist(arc->getLength()/2.1,
arc->getStartpoint());
} else {
middlePoint = RS_Vector{false};
middlePoint2 = RS_Vector{false};
}
if (middlePoint.valid) {
bool onContour=false;
if (RS_Information::isPointInsideContour(
middlePoint,
this, &onContour) ||
RS_Information::isPointInsideContour(middlePoint2, this)) {
RS_Entity* te = e->clone();
te->setPen(RS2::FlagInvalid);
te->setLayer(nullptr);
te->reparent(hatch);
hatch->addEntity(te);
}
}
}
addEntity(hatch);
//getGraphic()->addEntity(rubbish);
forcedCalculateBorders();
// deactivate contour:
activateContour(false);
updateRunning = false;
RS_DEBUG->print("RS_Hatch::update: OK");
}
void RS_ActionDrawHatch::trigger() {
RS_DEBUG->print("RS_ActionDrawHatch::trigger()");
//if (pos.valid) {
//deletePreview();
RS_Entity* e;
// deselect unhatchable entities:
for(auto e: *container){
if (e->isSelected() &&
(e->rtti()==RS2::EntityHatch ||
/* e->rtti()==RS2::EntityEllipse ||*/ e->rtti()==RS2::EntityPoint ||
e->rtti()==RS2::EntityMText || e->rtti()==RS2::EntityText ||
RS_Information::isDimension(e->rtti()))) {
e->setSelected(false);
}
}
for (e=container->firstEntity(RS2::ResolveAll); e;
e=container->nextEntity(RS2::ResolveAll)) {
if (e->isSelected() &&
(e->rtti()==RS2::EntityHatch ||
/* e->rtti()==RS2::EntityEllipse ||*/ e->rtti()==RS2::EntityPoint ||
e->rtti()==RS2::EntityMText || e->rtti()==RS2::EntityText ||
RS_Information::isDimension(e->rtti()))) {
e->setSelected(false);
}
}
// look for selected contours:
bool haveContour = false;
for (e=container->firstEntity(RS2::ResolveAll); e;
e=container->nextEntity(RS2::ResolveAll)) {
if (e->isSelected()) {
haveContour = true;
}
}
if (!haveContour) {
std::cerr << "no contour selected\n";
return;
}
hatch = new RS_Hatch(container, data);
hatch->setLayerToActive();
hatch->setPenToActive();
RS_EntityContainer* loop = new RS_EntityContainer(hatch);
loop->setPen(RS_Pen(RS2::FlagInvalid));
// add selected contour:
for (RS_Entity* e=container->firstEntity(RS2::ResolveAll); e;
e=container->nextEntity(RS2::ResolveAll)) {
if (e->isSelected()) {
e->setSelected(false);
// entity is part of a complex entity (spline, polyline, ..):
if (e->getParent() &&
// RVT - Don't de-delect the parent EntityPolyline, this is messing up the getFirst and getNext iterators
// (e->getParent()->rtti()==RS2::EntitySpline ||
// e->getParent()->rtti()==RS2::EntityPolyline)) {
(e->getParent()->rtti()==RS2::EntitySpline)) {
e->getParent()->setSelected(false);
}
RS_Entity* cp = e->clone();
cp->setPen(RS_Pen(RS2::FlagInvalid));
cp->reparent(loop);
loop->addEntity(cp);
}
}
hatch->addEntity(loop);
if (hatch->validate()) {
container->addEntity(hatch);
if (document) {
document->startUndoCycle();
document->addUndoable(hatch);
document->endUndoCycle();
}
hatch->update();
graphicView->redraw(RS2::RedrawDrawing);
bool printArea=true;
switch( hatch->getUpdateError()) {
case RS_Hatch::HATCH_OK :
RS_DIALOGFACTORY->commandMessage(tr("Hatch created successfully."));
break;
case RS_Hatch::HATCH_INVALID_CONTOUR :
RS_DIALOGFACTORY->commandMessage(tr("Hatch Error: Invalid contour found!"));
printArea=false;
break;
case RS_Hatch::HATCH_PATTERN_NOT_FOUND :
RS_DIALOGFACTORY->commandMessage(tr("Hatch Error: Pattern not found!"));
break;
case RS_Hatch::HATCH_TOO_SMALL :
RS_DIALOGFACTORY->commandMessage(tr("Hatch Error: Contour or pattern too small!"));
break;
case RS_Hatch::HATCH_AREA_TOO_BIG :
RS_DIALOGFACTORY->commandMessage(tr("Hatch Error: Contour too big!"));
break;
default :
RS_DIALOGFACTORY->commandMessage(tr("Hatch Error: Undefined Error!"));
printArea=false;
break;
}
if(m_bShowArea&&printArea){
RS_DIALOGFACTORY->commandMessage(tr("Total hatch area = %1").
arg(hatch->getTotalArea(),10,'g',8));
}
}
else {
delete hatch;
hatch = nullptr;
RS_DIALOGFACTORY->commandMessage(tr("Invalid hatch area. Please check that "
"the entities chosen form one or more closed contours."));
}
//}
}
/**
* Rearranges the atomic entities in this container in a way that connected
* entities are stored in the right order and direction.
* Non-recoursive. Only affects atomic entities in this container.
*
* @retval true all contours were closed
* @retval false at least one contour is not closed
* to do: find closed contour by flood-fill
*/
bool RS_EntityContainer::optimizeContours() {
// std::cout<<"RS_EntityContainer::optimizeContours: begin"<<std::endl;
// DEBUG_HEADER
// std::cout<<"loop with count()="<<count()<<std::endl;
RS_DEBUG->print("RS_EntityContainer::optimizeContours");
RS_EntityContainer tmp;
tmp.setAutoUpdateBorders(false);
bool closed=true;
/** accept all full circles **/
QList<RS_Entity*> enList;
for(auto e1: entities){
if (!e1->isEdge() || e1->isContainer() ) {
enList<<e1;
continue;
}
//detect circles and whole ellipses
switch(e1->rtti()){
case RS2::EntityEllipse:
if(static_cast<RS_Ellipse*>(e1)->isEllipticArc())
continue;
case RS2::EntityCircle:
//directly detect circles, bug#3443277
tmp.addEntity(e1->clone());
enList<<e1;
default:
continue;
}
}
// std::cout<<"RS_EntityContainer::optimizeContours: 1"<<std::endl;
/** remove unsupported entities */
for(RS_Entity* it: enList)
removeEntity(it);
/** check and form a closed contour **/
// std::cout<<"RS_EntityContainer::optimizeContours: 2"<<std::endl;
/** the first entity **/
RS_Entity* current(nullptr);
if(count()>0) {
current=entityAt(0)->clone();
tmp.addEntity(current);
removeEntity(entityAt(0));
}else {
if(tmp.count()==0) return false;
}
// std::cout<<"RS_EntityContainer::optimizeContours: 3"<<std::endl;
RS_Vector vpStart;
RS_Vector vpEnd;
if(current){
vpStart=current->getStartpoint();
vpEnd=current->getEndpoint();
}
RS_Entity* next(nullptr);
// std::cout<<"RS_EntityContainer::optimizeContours: 4"<<std::endl;
/** connect entities **/
const QString errMsg=QObject::tr("Hatch failed due to a gap=%1 between (%2, %3) and (%4, %5)");
while(count()>0){
double dist(0.);
RS_Vector&& vpTmp=getNearestEndpoint(vpEnd,&dist,&next);
if(dist>1e-8) {
if(vpEnd.squaredTo(vpStart)<1e-8){
RS_Entity* e2=entityAt(0);
tmp.addEntity(e2->clone());
vpStart=e2->getStartpoint();
vpEnd=e2->getEndpoint();
removeEntity(e2);
continue;
}
QG_DIALOGFACTORY->commandMessage(errMsg.arg(dist).arg(vpTmp.x).arg(vpTmp.y).arg(vpEnd.x).arg(vpEnd.y));
closed=false;
}
if(next && closed){ //workaround if next is nullptr
next->setProcessed(true);
RS_Entity* eTmp = next->clone();
if(vpEnd.squaredTo(eTmp->getStartpoint())>vpEnd.squaredTo(eTmp->getEndpoint()))
eTmp->revertDirection();
vpEnd=eTmp->getEndpoint();
tmp.addEntity(eTmp);
removeEntity(next);
} else { //workaround if next is nullptr
// std::cout<<"RS_EntityContainer::optimizeContours: next is nullptr" <<std::endl;
closed=false; //workaround if next is nullptr
break; //workaround if next is nullptr
} //workaround if next is nullptr
}
// DEBUG_HEADER
if(vpEnd.valid && vpEnd.squaredTo(vpStart)>1e-8) {
if(closed) QG_DIALOGFACTORY->commandMessage(errMsg.arg(vpEnd.distanceTo(vpStart))
.arg(vpStart.x).arg(vpStart.y).arg(vpEnd.x).arg(vpEnd.y));
closed=false;
}
// std::cout<<"RS_EntityContainer::optimizeContours: 5"<<std::endl;
// add new sorted entities:
for(auto en: tmp){
en->setProcessed(false);
addEntity(en->clone());
}
// std::cout<<"RS_EntityContainer::optimizeContours: 6"<<std::endl;
RS_DEBUG->print("RS_EntityContainer::optimizeContours: OK");
// std::cout<<"RS_EntityContainer::optimizeContours: end: count()="<<count()<<std::endl;
// std::cout<<"RS_EntityContainer::optimizeContours: closed="<<closed<<std::endl;
return closed;
}
/**
* Rearranges the atomic entities in this container in a way that connected
* entities are stored in the right order and direction.
* Non-recoursive. Only affects atomic entities in this container.
*
* @retval true all contours were closed
* @retval false at least one contour is not closed
*/
bool RS_ActionPolylineSegment::convertPolyline(RS_Entity* selectedEntity) {
RS_DEBUG->print("RS_ActionPolylineSegment::convertPolyline");
RS_Vector current(false);
RS_Vector start(false);
RS_Vector end(false);
RS_EntityContainer tmp;
bool closed = true;
int pos = container->findEntity(selectedEntity);
RS_Entity* e1=container->entityAt(pos);
if (!e1) return false;
if (document!=NULL) {
document->startUndoCycle();
}
if (document!=NULL) {
if (e1!=NULL && e1->isEdge() && !e1->isContainer() &&
!e1->isProcessed()) {
RS_AtomicEntity* ce = (RS_AtomicEntity*)e1;
///////////////////////////////////////////////////
ce->setUndoState(true);
document->addUndoable(ce);
///////////////////////////////////////////////////
// next contour start:
ce->setProcessed(true);
tmp.addEntity(ce->clone());
current = ce->getStartpoint();
end = ce->getEndpoint();
// find first connected entities:
for (int ei=pos-1; ei>=0; --ei) {
RS_Entity* e2=container->entityAt(ei);
if (e2!=NULL && e2->isEdge() && !e2->isContainer() &&
!e2->isProcessed()) {
RS_AtomicEntity* e = (RS_AtomicEntity*)e2;
///////////////////////////////////////////////////
e->setUndoState(true);
document->addUndoable(e);
///////////////////////////////////////////////////
if (e->getEndpoint().distanceTo(current) <
1.0e-4) {
e->setProcessed(true);
tmp.insertEntity(0,e->clone());
current = e->getStartpoint();
} else if (e->getStartpoint().distanceTo(current) <
1.0e-4) {
e->setProcessed(true);
RS_AtomicEntity* cl = (RS_AtomicEntity*)e->clone();
cl->reverse();
tmp.insertEntity(0,cl);
current = cl->getStartpoint();
}else
break;
}
}
if (current.distanceTo(end)>1.0e-4) {
closed = false;
}
current = ce->getEndpoint();
start = ce->getStartpoint();
// find last connected entities:
for (uint ei=pos+1; ei<container->count(); ++ei) {
RS_Entity* e2=container->entityAt(ei);
///////////////////////////////////////////////////
e2->setUndoState(true);
document->addUndoable(e2);
///////////////////////////////////////////////////
if (e2!=NULL && e2->isEdge() && !e2->isContainer() &&
!e2->isProcessed()) {
RS_AtomicEntity* e = (RS_AtomicEntity*)e2;
if (e->getStartpoint().distanceTo(current) <
1.0e-4) {
e->setProcessed(true);
tmp.addEntity(e->clone());
current = e->getEndpoint();
} else if (e->getEndpoint().distanceTo(current) <
1.0e-4) {
e->setProcessed(true);
RS_AtomicEntity* cl = (RS_AtomicEntity*)e->clone();
cl->reverse();
tmp.addEntity(cl);
current = cl->getEndpoint();
}else
break;
}
}
if (current.distanceTo(start)>1.0e-4) {
closed = false;
}
}
}
if (document!=NULL) {
document->endUndoCycle();
}
RS_Polyline* newPolyline = new RS_Polyline(container, RS_PolylineData(RS_Vector(false), RS_Vector(false), closed));
newPolyline->setLayerToActive();
newPolyline->setPenToActive();
// add new polyline:
bool first = true;
RS_Entity* lastEntity = tmp.lastEntity();
for (RS_Entity* en=tmp.firstEntity(); en!=NULL; en=tmp.nextEntity()) {
en->setProcessed(false);
double bulge = 0.0;
if (en->rtti()==RS2::EntityArc) {
bulge = ((RS_Arc*)en)->getBulge();
} else {
bulge = 0.0;
}
if (first) {
newPolyline->setNextBulge(bulge);
newPolyline->addVertex(((RS_AtomicEntity*)en)->getStartpoint());
first = false;
}
if (en!=lastEntity || closed==false){
newPolyline->setNextBulge(bulge);
newPolyline->addVertex(((RS_AtomicEntity*)en)->getEndpoint());
}
}
double bulge = lastEntity->rtti() == RS2::EntityArc? ((RS_Arc*)lastEntity)->getBulge():0.0;
newPolyline->setNextBulge(bulge);
newPolyline->endPolyline();
container->addEntity(newPolyline);
if (graphicView!=NULL) {
graphicView->drawEntity(newPolyline);
}
if (document!=NULL) {
document->startUndoCycle();
document->addUndoable(newPolyline);
document->endUndoCycle();
}
RS_DEBUG->print("RS_ActionPolylineSegment::convertPolyline: OK");
return closed;
}
void RS_ActionDrawHatch::trigger() {
RS_DEBUG->print("RS_ActionDrawHatch::trigger()");
//if (pos.valid) {
//deletePreview();
RS_Entity* e;
// deselect unhatchable entities:
for (e=container->firstEntity(RS2::ResolveNone); e!=NULL;
e=container->nextEntity(RS2::ResolveNone)) {
if (e->isSelected() &&
(e->rtti()==RS2::EntityHatch ||
/* e->rtti()==RS2::EntityEllipse ||*/ e->rtti()==RS2::EntityPoint ||
e->rtti()==RS2::EntityMText || e->rtti()==RS2::EntityText ||
RS_Information::isDimension(e->rtti()))) {
e->setSelected(false);
}
}
for (e=container->firstEntity(RS2::ResolveAll); e!=NULL;
e=container->nextEntity(RS2::ResolveAll)) {
if (e->isSelected() &&
(e->rtti()==RS2::EntityHatch ||
/* e->rtti()==RS2::EntityEllipse ||*/ e->rtti()==RS2::EntityPoint ||
e->rtti()==RS2::EntityMText || e->rtti()==RS2::EntityText ||
RS_Information::isDimension(e->rtti()))) {
e->setSelected(false);
}
}
// look for selected contours:
bool haveContour = false;
for (e=container->firstEntity(RS2::ResolveAll); e!=NULL;
e=container->nextEntity(RS2::ResolveAll)) {
if (e->isSelected()) {
haveContour = true;
}
}
if (!haveContour) {
std::cerr << "no contour selected\n";
return;
}
hatch = new RS_Hatch(container, data);
hatch->setLayerToActive();
hatch->setPenToActive();
RS_EntityContainer* loop = new RS_EntityContainer(hatch);
loop->setPen(RS_Pen(RS2::FlagInvalid));
// add selected contour:
for (RS_Entity* e=container->firstEntity(RS2::ResolveAll); e!=NULL;
e=container->nextEntity(RS2::ResolveAll)) {
if (e->isSelected()) {
e->setSelected(false);
// entity is part of a complex entity (spline, polyline, ..):
if (e->getParent()!=NULL &&
// RVT - Don't de-delect the parent EntityPolyline, this is messing up the getFirst and getNext iterators
// (e->getParent()->rtti()==RS2::EntitySpline ||
// e->getParent()->rtti()==RS2::EntityPolyline)) {
(e->getParent()->rtti()==RS2::EntitySpline)) {
e->getParent()->setSelected(false);
}
RS_Entity* cp = e->clone();
cp->setPen(RS_Pen(RS2::FlagInvalid));
cp->reparent(loop);
loop->addEntity(cp);
}
}
hatch->addEntity(loop);
if (hatch->validate()) {
container->addEntity(hatch);
if (document) {
document->startUndoCycle();
document->addUndoable(hatch);
document->endUndoCycle();
}
hatch->update();
graphicView->redraw(RS2::RedrawDrawing);
RS_DIALOGFACTORY->commandMessage(tr("Hatch created successfully."));
}
else {
delete hatch;
hatch = NULL;
RS_DIALOGFACTORY->commandMessage(tr("Invalid hatch area. Please check that "
"the entities chosen form one or more closed contours."));
}
//}
}
/**
* Updates the Inserts (letters) of this text. Called when the
* text or it's data, position, alignment, .. changes.
* This method also updates the usedTextWidth / usedTextHeight property.
*/
void RS_MText::update() {
RS_DEBUG->print("RS_Text::update");
clear();
if (isUndone()) {
return;
}
usedTextWidth = 0.0;
usedTextHeight = 0.0;
RS_Font* font = RS_FONTLIST->requestFont(data.style);
if (font==NULL) {
return;
}
RS_Vector letterPos = RS_Vector(0.0, -9.0);
RS_Vector letterSpace = RS_Vector(font->getLetterSpacing(), 0.0);
RS_Vector space = RS_Vector(font->getWordSpacing(), 0.0);
int lineCounter = 0;
// Every single text line gets stored in this entity container
// so we can move the whole line around easely:
RS_EntityContainer* oneLine = new RS_EntityContainer(this);
// First every text line is created with
// alignement: top left
// angle: 0
// height: 9.0
// Rotation, scaling and centering is done later
// For every letter:
for (int i=0; i<(int)data.text.length(); ++i) {
bool handled = false;
switch (data.text.at(i).unicode()) {
case 0x0A:
// line feed:
updateAddLine(oneLine, lineCounter++);
oneLine = new RS_EntityContainer(this);
letterPos = RS_Vector(0.0, -9.0);
break;
case 0x20:
// Space:
letterPos+=space;
break;
case 0x5C: {
// code (e.g. \S, \P, ..)
i++;
int ch = data.text.at(i).unicode();
switch (ch) {
case 'P':
updateAddLine(oneLine, lineCounter++);
oneLine = new RS_EntityContainer(this);
letterPos = RS_Vector(0.0, -9.0);
handled = true;
break;
case 'f':
case 'F':
//font change
// \f{symbol} changes font to symbol
// \f{} sets font to standard
{
i++;
if(data.text.at(i).unicode()!='{') {
i--;
continue;
}
int j=data.text.indexOf('}',i);
if(j>i){
//
QString fontName;
if(j==i+1)
fontName="standard";
else
fontName=data.text.mid(i+1,j-i-1);
RS_Font* fontNew = RS_FONTLIST->requestFont(
fontName
);
if(fontNew != NULL) {
font=fontNew;
}
if(font==NULL) font = RS_FONTLIST->requestFont("standard");
i=j;
}
}
continue;
case 'S': {
QString up;
QString dw;
//letterPos += letterSpace;
// get upper string:
i++;
while (data.text.at(i).unicode()!='^' &&
//data.text.at(i).unicode()!='/' &&
data.text.at(i).unicode()!='\\' &&
//data.text.at(i).unicode()!='#' &&
i<(int)data.text.length()) {
up += data.text.at(i);
i++;
}
i++;
if (data.text.at(i-1).unicode()=='^' &&
data.text.at(i).unicode()==' ') {
i++;
}
// get lower string:
while (data.text.at(i).unicode()!=';' &&
i<(int)data.text.length()) {
dw += data.text.at(i);
i++;
}
// add texts:
RS_MText* upper =
new RS_MText(
oneLine,
RS_MTextData(letterPos + RS_Vector(0.0,9.0),
4.0, 100.0, RS_MTextData::VATop, RS_MTextData::HALeft,
RS_MTextData::LeftToRight, RS_MTextData::Exact,
1.0, up, data.style,
0.0, RS2::Update));
upper->setLayer(NULL);
upper->setPen(RS_Pen(RS2::FlagInvalid));
oneLine->addEntity(upper);
RS_MText* lower =
new RS_MText(
oneLine,
RS_MTextData(letterPos+RS_Vector(0.0,4.0),
4.0, 100.0, RS_MTextData::VATop, RS_MTextData::HALeft,
RS_MTextData::LeftToRight, RS_MTextData::Exact,
1.0, dw, data.style,
0.0, RS2::Update));
lower->setLayer(NULL);
lower->setPen(RS_Pen(RS2::FlagInvalid));
oneLine->addEntity(lower);
// move cursor:
upper->calculateBorders();
lower->calculateBorders();
double w1 = upper->getSize().x;
double w2 = lower->getSize().x;
if (w1>w2) {
letterPos += RS_Vector(w1, 0.0);
} else {
letterPos += RS_Vector(w2, 0.0);
}
letterPos += letterSpace;
}
handled = true;
break;
default:
i--;
break;
}
}
//if char is not handled continue in default: statement
if (handled)
break;
default: {
// One Letter:
QString letterText = QString(data.text.at(i));
if (font->findLetter(letterText) == NULL) {
RS_DEBUG->print("RS_Text::update: missing font for letter( %s ), replaced it with QChar(0xfffd)",qPrintable(letterText));
letterText = QChar(0xfffd);
}
// if (font->findLetter(QString(data.text.at(i))) != NULL) {
RS_DEBUG->print("RS_Text::update: insert a "
"letter at pos: %f/%f", letterPos.x, letterPos.y);
RS_InsertData d(letterText,
letterPos,
RS_Vector(1.0, 1.0),
0.0,
1,1, RS_Vector(0.0,0.0),
font->getLetterList(), RS2::NoUpdate);
RS_Insert* letter = new RS_Insert(this, d);
RS_Vector letterWidth;
letter->setPen(RS_Pen(RS2::FlagInvalid));
letter->setLayer(NULL);
letter->update();
letter->forcedCalculateBorders();
// until 2.0.4.5:
//letterWidth = RS_Vector(letter->getSize().x, 0.0);
// from 2.0.4.6:
letterWidth = RS_Vector(letter->getMax().x-letterPos.x, 0.0);
if (letterWidth.x < 0)
letterWidth.x = -letterSpace.x;
oneLine->addEntity(letter);
// next letter position:
letterPos += letterWidth;
letterPos += letterSpace;
// }
}
break;
}
}
double tt = updateAddLine(oneLine, lineCounter);
if (data.valign == RS_MTextData::VABottom) {
RS_Vector ot = RS_Vector(0.0,-tt).rotate(data.angle);
RS_EntityContainer::move(ot);
}
usedTextHeight -= data.height*data.lineSpacingFactor*5.0/3.0
- data.height;
forcedCalculateBorders();
RS_DEBUG->print("RS_Text::update: OK");
}
/**
* Updates the Hatch. Called when the
* hatch or it's data, position, alignment, .. changes.
*/
void RS_Hatch::update() {
RS_DEBUG->print("RS_Hatch::update");
RS_DEBUG->print("RS_Hatch::update: contour has %d loops", count());
if (updateRunning) {
return;
}
if (updateEnabled==false) {
return;
}
if (data.solid==true) {
calculateBorders();
return;
}
RS_DEBUG->print("RS_Hatch::update");
updateRunning = true;
// delete old hatch:
if (hatch!=NULL) {
removeEntity(hatch);
hatch = NULL;
}
if (isUndone()) {
updateRunning = false;
return;
}
if (!validate()) {
RS_DEBUG->print(RS_Debug::D_WARNING,
"RS_Hatch::update: invalid contour in hatch found");
updateRunning = false;
return;
}
// search pattern:
RS_DEBUG->print("RS_Hatch::update: requesting pattern");
RS_Pattern* pat = RS_PATTERNLIST->requestPattern(data.pattern);
if (pat==NULL) {
updateRunning = false;
RS_DEBUG->print("RS_Hatch::update: requesting pattern: not found");
return;
}
RS_DEBUG->print("RS_Hatch::update: requesting pattern: OK");
RS_DEBUG->print("RS_Hatch::update: cloning pattern");
pat = (RS_Pattern*)pat->clone();
RS_DEBUG->print("RS_Hatch::update: cloning pattern: OK");
// scale pattern
RS_DEBUG->print("RS_Hatch::update: scaling pattern");
pat->scale(RS_Vector(0.0,0.0), RS_Vector(data.scale, data.scale));
pat->calculateBorders();
forcedCalculateBorders();
RS_DEBUG->print("RS_Hatch::update: scaling pattern: OK");
// find out how many pattern-instances we need in x/y:
int px1, py1, px2, py2;
double f;
RS_Hatch* copy = (RS_Hatch*)this->clone();
copy->rotate(RS_Vector(0.0,0.0), -data.angle);
copy->forcedCalculateBorders();
// create a pattern over the whole contour.
RS_Vector pSize = pat->getSize();
// RS_Vector cPos = getMin();
RS_Vector cSize = getSize();
RS_DEBUG->print("RS_Hatch::update: pattern size: %f/%f", pSize.x, pSize.y);
RS_DEBUG->print("RS_Hatch::update: contour size: %f/%f", cSize.x, cSize.y);
if (cSize.x<1.0e-6 || cSize.y<1.0e-6 ||
pSize.x<1.0e-6 || pSize.y<1.0e-6 ||
cSize.x>RS_MAXDOUBLE-1 || cSize.y>RS_MAXDOUBLE-1 ||
pSize.x>RS_MAXDOUBLE-1 || pSize.y>RS_MAXDOUBLE-1) {
delete pat;
delete copy;
updateRunning = false;
RS_DEBUG->print("RS_Hatch::update: contour size or pattern size too small");
return;
}
// avoid huge memory consumption:
else if (cSize.x/pSize.x>100 || cSize.y/pSize.y>100) {
RS_DEBUG->print("RS_Hatch::update: contour size too large or pattern size too small");
return;
}
f = copy->getMin().x/pat->getSize().x;
px1 = (int)floor(f);
f = copy->getMin().y/pat->getSize().y;
py1 = (int)floor(f);
f = copy->getMax().x/pat->getSize().x;
px2 = (int)ceil(f) - 1;
f = copy->getMax().y/pat->getSize().y;
py2 = (int)ceil(f) - 1;
RS_EntityContainer tmp; // container for untrimmed lines
// adding array of patterns to tmp:
RS_DEBUG->print("RS_Hatch::update: creating pattern carpet");
for (int px=px1; px<=px2; px++) {
for (int py=py1; py<=py2; py++) {
for (RS_Entity* e=pat->firstEntity(); e!=NULL;
e=pat->nextEntity()) {
RS_Entity* te = e->clone();
te->rotate(RS_Vector(0.0,0.0), data.angle);
RS_Vector v1, v2;
v1.setPolar(px*pSize.x, data.angle);
v2.setPolar(py*pSize.y, data.angle+M_PI/2.0);
te->move(v1+v2);
tmp.addEntity(te);
}
}
}
delete pat;
pat = NULL;
RS_DEBUG->print("RS_Hatch::update: creating pattern carpet: OK");
RS_DEBUG->print("RS_Hatch::update: cutting pattern carpet");
// cut pattern to contour shape:
RS_EntityContainer tmp2; // container for small cut lines
RS_Line* line = NULL;
RS_Arc* arc = NULL;
RS_Circle* circle = NULL;
RS_Ellipse* ellipse = NULL;
for (RS_Entity* e=tmp.firstEntity(); e!=NULL;
e=tmp.nextEntity()) {
RS_Vector startPoint;
RS_Vector endPoint;
RS_Vector center = RS_Vector(false);
bool reversed;
switch(e->rtti()){
case RS2::EntityLine:
line=static_cast<RS_Line*>(e);
startPoint = line->getStartpoint();
endPoint = line->getEndpoint();
break;
case RS2::EntityArc:
arc=static_cast<RS_Arc*>(e);
startPoint = arc->getStartpoint();
endPoint = arc->getEndpoint();
center = arc->getCenter();
reversed = arc->isReversed();
break;
case RS2::EntityCircle:
circle=static_cast<RS_Circle*>(e);
startPoint = circle->getCenter()
+ RS_Vector(circle->getRadius(), 0.0);
endPoint = startPoint;
center = circle->getCenter();
break;
case RS2::EntityEllipse:
ellipse = static_cast<RS_Ellipse*>(e);
startPoint = ellipse->getStartpoint();
endPoint = ellipse->getEndpoint();
center = ellipse->getCenter();
reversed = ellipse->isReversed();
break;
default:
continue;
}
// getting all intersections of this pattern line with the contour:
QList<std::shared_ptr<RS_Vector> > is;
is.append(std::shared_ptr<RS_Vector>(new RS_Vector(startPoint)));
for (RS_Entity* loop=firstEntity(); loop!=NULL;
loop=nextEntity()) {
if (loop->isContainer()) {
for (RS_Entity* p=((RS_EntityContainer*)loop)->firstEntity();
p!=NULL;
p=((RS_EntityContainer*)loop)->nextEntity()) {
RS_VectorSolutions sol =
RS_Information::getIntersection(e, p, true);
for (int i=0; i<=1; ++i) {
if (sol.get(i).valid) {
is.append(std::shared_ptr<RS_Vector>(
new RS_Vector(sol.get(i))
));
RS_DEBUG->print(" pattern line intersection: %f/%f",
sol.get(i).x, sol.get(i).y);
}
}
}
}
}
is.append(std::shared_ptr<RS_Vector>(new RS_Vector(endPoint)));
// sort the intersection points into is2:
RS_Vector sp = startPoint;
double sa = center.angleTo(sp);
if(ellipse != NULL) sa=ellipse->getEllipseAngle(sp);
QList<std::shared_ptr<RS_Vector> > is2;
bool done;
double minDist;
double dist = 0.0;
std::shared_ptr<RS_Vector> av;
std::shared_ptr<RS_Vector> v;
RS_Vector last = RS_Vector(false);
do {
done = true;
minDist = RS_MAXDOUBLE;
av.reset();
for (int i = 0; i < is.size(); ++i) {
v = is.at(i);
double a;
switch(e->rtti()){
case RS2::EntityLine:
dist = sp.distanceTo(*v);
break;
case RS2::EntityArc:
case RS2::EntityCircle:
a = center.angleTo(*v);
dist = reversed?
fmod(sa - a + 2.*M_PI,2.*M_PI):
fmod(a - sa + 2.*M_PI,2.*M_PI);
break;
case RS2::EntityEllipse:
a = ellipse->getEllipseAngle(*v);
dist = reversed?
fmod(sa - a + 2.*M_PI,2.*M_PI):
fmod(a - sa + 2.*M_PI,2.*M_PI);
break;
default:
break;
}
if (dist<minDist) {
minDist = dist;
done = false;
av = v;
}
}
// copy to sorted list, removing double points
if (!done && av.get()!=NULL) {
if (last.valid==false || last.distanceTo(*av)>RS_TOLERANCE) {
is2.append(std::shared_ptr<RS_Vector>(new RS_Vector(*av)));
last = *av;
}
#if QT_VERSION < 0x040400
emu_qt44_removeOne(is, av);
#else
is.removeOne(av);
#endif
av.reset();
}
} while(!done);
// add small cut lines / arcs to tmp2:
for (int i = 1; i < is2.size(); ++i) {
auto v1 = is2.at(i-1);
auto v2 = is2.at(i);
if (line!=NULL) {
tmp2.addEntity(new RS_Line(&tmp2,
RS_LineData(*v1, *v2)));
} else if (arc!=NULL || circle!=NULL) {
tmp2.addEntity(new RS_Arc(&tmp2,
RS_ArcData(center,
center.distanceTo(*v1),
center.angleTo(*v1),
center.angleTo(*v2),
reversed)));
}
}
}
// updating hatch / adding entities that are inside
RS_DEBUG->print("RS_Hatch::update: cutting pattern carpet: OK");
//RS_EntityContainer* rubbish = new RS_EntityContainer(getGraphic());
// the hatch pattern entities:
hatch = new RS_EntityContainer(this);
hatch->setPen(RS_Pen(RS2::FlagInvalid));
hatch->setLayer(NULL);
hatch->setFlag(RS2::FlagTemp);
//calculateBorders();
for (RS_Entity* e=tmp2.firstEntity(); e!=NULL;
e=tmp2.nextEntity()) {
RS_Vector middlePoint;
RS_Vector middlePoint2;
if (e->rtti()==RS2::EntityLine) {
RS_Line* line = (RS_Line*)e;
middlePoint = line->getMiddlePoint();
middlePoint2 = line->getNearestDist(line->getLength()/2.1,
line->getStartpoint());
} else if (e->rtti()==RS2::EntityArc) {
RS_Arc* arc = (RS_Arc*)e;
middlePoint = arc->getMiddlePoint();
middlePoint2 = arc->getNearestDist(arc->getLength()/2.1,
arc->getStartpoint());
} else {
middlePoint = RS_Vector(false);
middlePoint2 = RS_Vector(false);
}
if (middlePoint.valid) {
bool onContour=false;
if (RS_Information::isPointInsideContour(
middlePoint,
this, &onContour) ||
RS_Information::isPointInsideContour(middlePoint2, this)) {
RS_Entity* te = e->clone();
te->setPen(RS_Pen(RS2::FlagInvalid));
te->setLayer(NULL);
te->reparent(hatch);
hatch->addEntity(te);
}
}
}
addEntity(hatch);
//getGraphic()->addEntity(rubbish);
forcedCalculateBorders();
// deactivate contour:
activateContour(false);
updateRunning = false;
RS_DEBUG->print("RS_Hatch::update: OK");
}
/**
* Rearranges the atomic entities in this container in a way that connected
* entities are stored in the right order and direction.
* Non-recoursive. Only affects atomic entities in this container.
*
* @retval true all contours were closed
* @retval false at least one contour is not closed
*/
bool RS_EntityContainer::optimizeContours() {
RS_DEBUG->print("RS_EntityContainer::optimizeContours");
RS_Vector current(false);
RS_Vector start(false);
RS_EntityContainer tmp;
bool changed = false;
bool closed = true;
for (uint ci=0; ci<count(); ++ci) {
RS_Entity* e1=entityAt(ci);
if (e1!=NULL && e1->isEdge() && !e1->isContainer() &&
!e1->isProcessed()) {
RS_AtomicEntity* ce = (RS_AtomicEntity*)e1;
// next contour start:
ce->setProcessed(true);
tmp.addEntity(ce->clone());
current = ce->getEndpoint();
start = ce->getStartpoint();
// find all connected entities:
bool done;
do {
done = true;
for (uint ei=0; ei<count(); ++ei) {
RS_Entity* e2=entityAt(ei);
if (e2!=NULL && e2->isEdge() && !e2->isContainer() &&
!e2->isProcessed()) {
RS_AtomicEntity* e = (RS_AtomicEntity*)e2;
if (e->getStartpoint().distanceTo(current) <
1.0e-4) {
e->setProcessed(true);
tmp.addEntity(e->clone());
current = e->getEndpoint();
done=false;
} else if (e->getEndpoint().distanceTo(current) <
1.0e-4) {
e->setProcessed(true);
RS_AtomicEntity* cl = (RS_AtomicEntity*)e->clone();
cl->reverse();
tmp.addEntity(cl);
current = cl->getEndpoint();
changed = true;
done=false;
}
}
}
if (!done) {
changed = true;
}
} while (!done);
if (current.distanceTo(start)>1.0e-4) {
closed = false;
}
}
}
// remove all atomic entities:
bool done;
do {
done = true;
for (RS_Entity* en=firstEntity(); en!=NULL; en=nextEntity()) {
if (!en->isContainer()) {
removeEntity(en);
done = false;
break;
}
}
} while (!done);
// add new sorted entities:
for (RS_Entity* en=tmp.firstEntity(); en!=NULL; en=tmp.nextEntity()) {
en->setProcessed(false);
addEntity(en->clone());
}
RS_DEBUG->print("RS_EntityContainer::optimizeContours: OK");
return closed;
}