-// Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
-
-// File: SketchPlugin_Trim.cpp
-// Created: 22 Feb 2017
-// Author: Natalia ERMOLAEVA
+// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
#include "SketchPlugin_Trim.h"
#include <SketchPlugin_Circle.h>
#include <SketchPlugin_ConstraintCoincidence.h>
#include <SketchPlugin_ConstraintEqual.h>
-//#include <SketchPlugin_ConstraintParallel.h>
#include <SketchPlugin_ConstraintTangent.h>
#include <SketchPlugin_ConstraintLength.h>
#include <SketchPlugin_ConstraintMirror.h>
#include <SketchPlugin_MultiRotation.h>
#include <SketchPlugin_MultiTranslation.h>
#include <SketchPlugin_Point.h>
+#include <SketchPlugin_Projection.h>
+#include <SketchPlugin_Tools.h>
+
+#include <ModelAPI_EventReentrantMessage.h>
#include <ModelAPI_Events.h>
#include <SketchPlugin_Line.h>
#include <cmath>
-#define DEBUG_TRIM
#ifdef DEBUG_TRIM
#include <iostream>
#endif
+#ifdef DEBUG_TRIM_METHODS
+#include <iostream>
+#endif
+
static const double PI = 3.141592653589793238463;
static const std::string OPERATION_HIGHLIGHT_COLOR() { return "128, 0, 0"; }
void SketchPlugin_Trim::initAttributes()
{
- data()->addAttribute(SketchPlugin_Trim::SELECTED_OBJECT(),
- ModelAPI_AttributeReference::typeId());
+ data()->addAttribute(SELECTED_OBJECT(), ModelAPI_AttributeReference::typeId());
data()->addAttribute(SELECTED_POINT(), GeomDataAPI_Point2D::typeId());
data()->addAttribute(PREVIEW_POINT(), GeomDataAPI_Point2D::typeId());
const std::shared_ptr<GeomAPI_Pnt>& thePoint)
{
std::shared_ptr<GeomAPI_Pnt2d> aPoint;
+ if (!thePoint.get())
+ return aPoint;
AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
data()->attribute(SketchPlugin_Trim::SELECTED_OBJECT()));
void SketchPlugin_Trim::execute()
{
-#ifdef DEBUG_TRIM
- std::cout << "SketchPlugin_Trim::execute" << std::endl;
+#ifdef DEBUG_TRIM_METHODS
+ std::cout << "SketchPlugin_Trim::execute: " << data()->name() << std::endl;
#endif
SketchPlugin_Sketch* aSketch = sketch();
- if (!aSketch)
+ if (!aSketch) {
+ setError("Error: Sketch object is empty.");
return;
+ }
// Check the base objects are initialized.
AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
return;
}
ObjectPtr aBaseObject = aBaseObjectAttr->value();
- if (!aBaseObject.get())
+ if (!aBaseObject.get()) {
+ setError("Error: Base object is not initialized.");
return;
+ }
FeaturePtr aBaseFeature = ModelAPI_Feature::feature(aBaseObjectAttr->value());
+ /// Remove reference of this feature to feature used in preview, it is not necessary anymore
+ /// as trim will be removed after execute
+ AttributeReferencePtr aPreviewObjectAttr =
+ std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::PREVIEW_OBJECT()));
+
+ ObjectPtr aPreviewObject = aPreviewObjectAttr->value();
+ AttributePoint2DPtr aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ data()->attribute(PREVIEW_POINT()));
+ std::shared_ptr<GeomAPI_Pnt2d> aPreviewPnt2d = aPoint->pnt();
+ // nullify pointer of preview attribute
+ aPreviewObjectAttr->setValue(ResultPtr());
+
+ bool anIsEqualPreviewAndSelected = aPreviewObject == aBaseObject;
+
/// points of trim
std::shared_ptr<GeomAPI_Pnt> aStartShapePoint, aLastShapePoint;
#ifdef DEBUG_TRIM
std::cout << " Base Feature: " << aBaseFeature->data()->name() << std::endl;
#endif
findShapePoints(SELECTED_OBJECT(), SELECTED_POINT(), aStartShapePoint, aLastShapePoint);
+ if (!aStartShapePoint || !aLastShapePoint) {
+ setError("Error: Selected point is not placed on any edge");
+ return;
+ }
std::shared_ptr<GeomAPI_Pnt2d> aStartShapePoint2d = convertPoint(aStartShapePoint);
-
std::shared_ptr<GeomAPI_Pnt2d> aLastShapePoint2d = convertPoint(aLastShapePoint);
-
- std::set<FeaturePtr> aFeaturesToDelete;
- getConstraints(aFeaturesToDelete);
-
+ /// find features that should be deleted (e.g. Middle Point) or updated (e.g. Length)
+ std::set<FeaturePtr> aFeaturesToDelete, aFeaturesToUpdate;
+ getConstraints(aFeaturesToDelete, aFeaturesToUpdate);
+ // find references(attributes and features) to the base feature
std::map<AttributePtr, std::list<AttributePtr> > aBaseRefAttributes;
std::list<AttributePtr> aRefsToFeature;
getRefAttributes(aBaseFeature, aBaseRefAttributes, aRefsToFeature);
std::cout << "[" << aRefsToFeature.size() << "] " << aRefsInfo << std::endl;
std::cout << "---- getRefAttributes:end ----" << std::endl;
#endif
- // coincidence to result points
- // find coincidences to the base object, it should be used when attribute is found
- // in myObjectToPoints
- //std::map<AttributePtr, FeaturePtr> aCoincidencesToBaseFeature;
- //getCoincidencesToObject(aBaseObject, aCoincidencesToBaseFeature);
+
+ keepCurrentFeature();
std::set<AttributePoint2DPtr> aFurtherCoincidences;
std::set<std::pair<AttributePtr, AttributePtr>> aModifiedAttributes;
const std::string& aKind = aBaseFeature->getKind();
- FeaturePtr aReplacingFeature;
+ FeaturePtr aReplacingFeature, aNewFeature;
if (aKind == SketchPlugin_Circle::ID()) {
aReplacingFeature = trimCircle(aStartShapePoint2d, aLastShapePoint2d,
aFurtherCoincidences, aModifiedAttributes);
// otherwise Trim feature will be removed with the circle before
// this operation is finished
aBaseObjectAttr->setObject(ResultPtr());
-
- AttributeReferencePtr aPreviewObjectAttr =
- std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
- data()->attribute(SketchPlugin_Trim::PREVIEW_OBJECT()));
- aPreviewObjectAttr->setObject(ResultPtr());
-
}
else if (aKind == SketchPlugin_Line::ID()) {
- trimLine(aStartShapePoint2d, aLastShapePoint2d, aBaseRefAttributes,
- aFurtherCoincidences, aModifiedAttributes);
+ aNewFeature = trimLine(aStartShapePoint2d, aLastShapePoint2d, aBaseRefAttributes,
+ aFurtherCoincidences, aModifiedAttributes);
}
else if (aKind == SketchPlugin_Arc::ID()) {
- trimArc(aStartShapePoint2d, aLastShapePoint2d, aBaseRefAttributes,
- aFurtherCoincidences, aModifiedAttributes);
+ aNewFeature = trimArc(aStartShapePoint2d, aLastShapePoint2d, aBaseRefAttributes,
+ aFurtherCoincidences, aModifiedAttributes);
}
+ restoreCurrentFeature();
+
// constraints to end points of trim feature
if (myObjectToPoints.find(aBaseObject) == myObjectToPoints.end())
fillObjectShapes(aBaseObject, sketch()->data()->owner(), myCashedShapes, myObjectToPoints);
const std::list<ObjectPtr>& anObjects = anInfo.second;
for (std::list<ObjectPtr>::const_iterator anObjectIt = anObjects.begin();
anObjectIt != anObjects.end(); anObjectIt++) {
- createConstraintToObject(SketchPlugin_ConstraintCoincidence::ID(), aPointAttribute,
- *anObjectIt);
+ SketchPlugin_Tools::createConstraintAttrObject(sketch(),
+ SketchPlugin_ConstraintCoincidence::ID(),
+ aPointAttribute, *anObjectIt);
}
}
anIt != aLast; anIt++) {
AttributePtr anAttribute = *anIt;
- //if (replaceCoincidenceAttribute(anAttribute, aModifiedAttributes))
- // continue;
+ if (setCoincidenceToAttribute(anAttribute, aFurtherCoincidences, aFeaturesToDelete))
+ continue;
- if (setCoincidenceToAttribute(anAttribute, aFurtherCoincidences))
+ // move tangency constraint to the nearest feature if possible
+ if (aNewFeature.get() && moveTangency(anAttribute, aNewFeature))
continue;
if (aReplacingResult.get()) {
Events_Loop::loop()->setFlushed(anUpdateEvent, false);
// delete constraints
+#ifdef DEBUG_TRIM
+ if (aFeaturesToDelete.size() > 0) {
+ std::cout << "after SPlit: removeFeaturesAndReferences: " << std::endl;
+ std::string aValue;
+ for (std::set<FeaturePtr>::const_iterator anIt = aFeaturesToDelete.begin();
+ anIt != aFeaturesToDelete.end(); anIt++) {
+ FeaturePtr aFeature = *anIt;
+ std::cout << aFeature->data()->name() << std::endl;
+ }
+ }
+#endif
ModelAPI_Tools::removeFeaturesAndReferences(aFeaturesToDelete);
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
+ updateFeaturesAfterTrim(aFeaturesToUpdate);
+
// Send events to update the sub-features by the solver.
if(isUpdateFlushed) {
Events_Loop::loop()->setFlushed(anUpdateEvent, true);
}
+ if (anIsEqualPreviewAndSelected) {
+ // equal preview and selected objects
+ // nothing to do if the preview and selected objects are different
+ if (aReplacingResult.get()) { // base object was removed
+ aPreviewObject = aReplacingResult;
+ //aMessage->setSelectedObject(aReplacingResult);
+#ifdef DEBUG_TRIM_METHODS
+ if (!aSelectedShape.get())
+ std::cout << "Set empty selected object" << std::endl;
+ else
+ std::cout << "Set shape with ShapeType: " << aSelectedShape->shapeTypeStr() << std::endl;
+#endif
+ }
+ else {
+ aPreviewObject = ObjectPtr();
+
+ aBaseFeature->execute(); // should recompute shapes of result to do not check obsolete one
+ aBaseObject = getFeatureResult(aBaseFeature);
+ std::shared_ptr<GeomAPI_Pnt> aPreviewPnt = sketch()->to3D(aPreviewPnt2d->x(),
+ aPreviewPnt2d->y());
+ ResultPtr aBaseResult = std::dynamic_pointer_cast<ModelAPI_Result>(aBaseObject);
+ if (aBaseResult) {
+ GeomShapePtr aShape = aBaseResult->shape();
+ std::shared_ptr<GeomAPI_Pnt> aProjectedPoint;
+ if (ModelGeomAlgo_Point2D::isPointOnEdge(aShape, aPreviewPnt, aProjectedPoint))
+ aPreviewObject = aBaseResult;
+ }
+ if (!aPreviewObject.get() && aNewFeature.get()) {
+ ResultPtr aNewFeatureResult = getFeatureResult(aNewFeature);
+ if (aNewFeatureResult.get()) {
+ GeomShapePtr aShape = aNewFeatureResult->shape();
+ std::shared_ptr<GeomAPI_Pnt> aProjectedPoint;
+ if (ModelGeomAlgo_Point2D::isPointOnEdge(aShape, aPreviewPnt, aProjectedPoint))
+ aPreviewObject = aNewFeatureResult;
+ }
+ }
+ }
+ }
+ if (aPreviewObject.get()) {
+ std::shared_ptr<ModelAPI_EventReentrantMessage> aMessage = std::shared_ptr
+ <ModelAPI_EventReentrantMessage>(new ModelAPI_EventReentrantMessage(
+ ModelAPI_EventReentrantMessage::eventId(), this));
+ aMessage->setSelectedObject(aPreviewObject);
+ Events_Loop::loop()->send(aMessage);
+ }
#ifdef DEBUG_TRIM
std::cout << "SketchPlugin_Trim::done" << std::endl;
#endif
}
+// LCOV_EXCL_START
+std::string SketchPlugin_Trim::processEvent(const std::shared_ptr<Events_Message>& theMessage)
+{
+#ifdef DEBUG_TRIM_METHODS
+ std::cout << "SketchPlugin_Trim::processEvent:" << data()->name() << std::endl;
+#endif
+ std::string aFilledAttributeName;
+
+ std::shared_ptr<ModelAPI_EventReentrantMessage> aMessage =
+ std::dynamic_pointer_cast<ModelAPI_EventReentrantMessage>(theMessage);
+ if (aMessage.get()) {
+ ObjectPtr anObject = aMessage->selectedObject();
+ std::shared_ptr<GeomAPI_Pnt2d> aPoint = aMessage->clickedPoint();
+
+ if (anObject.get() && aPoint.get()) {
+ if (myCashedShapes.find(anObject) == myCashedShapes.end())
+ fillObjectShapes(anObject, sketch()->data()->owner(), myCashedShapes, myObjectToPoints);
+ const std::set<GeomShapePtr>& aShapes = myCashedShapes[anObject];
+ if (aShapes.size() > 1) {
+ std::shared_ptr<ModelAPI_AttributeReference> aRefSelectedAttr =
+ std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::SELECTED_OBJECT()));
+ std::shared_ptr<ModelAPI_AttributeReference> aRefPreviewAttr =
+ std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
+ data()->attribute(SketchPlugin_Trim::PREVIEW_OBJECT()));
+ aRefSelectedAttr->setValue(anObject);
+ aRefPreviewAttr->setValue(anObject);
+
+ std::shared_ptr<GeomDataAPI_Point2D> aPointSelectedAttr =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ data()->attribute(SketchPlugin_Trim::SELECTED_POINT()));
+ std::shared_ptr<GeomDataAPI_Point2D> aPointPreviewAttr =
+ std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ data()->attribute(SketchPlugin_Trim::PREVIEW_POINT()));
+ aPointSelectedAttr->setValue(aPoint);
+ aPointPreviewAttr->setValue(aPoint);
+
+ Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
+
+ GeomShapePtr aSelectedShape = getSubShape(SELECTED_OBJECT(), SELECTED_POINT());
+ #ifdef DEBUG_TRIM_METHODS
+ if (!aSelectedShape.get())
+ std::cout << "Set empty selected object" << std::endl;
+ else
+ std::cout << "Set shape with ShapeType: " << aSelectedShape->shapeTypeStr() << std::endl;
+ #endif
+ aFilledAttributeName = SketchPlugin_Trim::SELECTED_OBJECT();
+ }
+ }
+ }
+ return aFilledAttributeName;
+}
+// LCOV_EXCL_STOP
+
bool SketchPlugin_Trim::setCoincidenceToAttribute(const AttributePtr& theAttribute,
- const std::set<AttributePoint2DPtr>& theFurtherCoincidences)
+ const std::set<AttributePoint2DPtr>& theFurtherCoincidences,
+ std::set<std::shared_ptr<ModelAPI_Feature>>& theFeaturesToDelete)
{
FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
if (aFeature->getKind() != SketchPlugin_ConstraintCoincidence::ID())
AttributePoint2DPtr aPointAttribute = (*anIt);
std::shared_ptr<GeomAPI_Pnt2d> aPoint2d = aPointAttribute->pnt();
if (aPoint2d->isEqual(aRefPnt2d)) {
- AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- theAttribute);
- if (aRefAttr.get()) {
- aRefAttr->setAttr(aPointAttribute);
- aFoundPoint = true;
- }
+ // create new coincidence and then remove the old one
+ SketchPlugin_Tools::createConstraintAttrAttr(sketch(),
+ SketchPlugin_ConstraintCoincidence::ID(),
+ aRefPointAttr, aPointAttribute);
+ theFeaturesToDelete.insert(aFeature);
}
}
return aFoundPoint;
}
-bool SketchPlugin_Trim::replaceCoincidenceAttribute(const AttributePtr& theCoincidenceAttribute,
- const std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes)
+bool SketchPlugin_Trim::moveTangency(const AttributePtr& theAttribute,
+ const FeaturePtr& theFeature)
{
- FeaturePtr aCoincidenceFeature = ModelAPI_Feature::feature(theCoincidenceAttribute->owner());
- if (aCoincidenceFeature->getKind() != SketchPlugin_ConstraintCoincidence::ID())
+ FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner());
+ if (aFeature->getKind() != SketchPlugin_ConstraintTangent::ID())
return false;
- AttributeRefAttrPtr aCAttrA = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aCoincidenceFeature->attribute(SketchPlugin_Constraint::ENTITY_A()));
- AttributeRefAttrPtr aCAttrB = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aCoincidenceFeature->attribute(SketchPlugin_Constraint::ENTITY_B()));
- AttributePtr aCAttrRefA = aCAttrA->attr();
- AttributePtr aCAttrRefB = aCAttrB->attr();
-
- bool isProcessed = false;
- for (std::set<std::pair<AttributePtr, AttributePtr>>::const_iterator
- anIt = theModifiedAttributes.begin(); anIt != theModifiedAttributes.end(); anIt++) {
- AttributePtr anAttributeBefore = anIt->first;
- if (anAttributeBefore == aCAttrRefA) {
- aCAttrA->setAttr(anIt->second);
- isProcessed = true;
- }
- if (anAttributeBefore == aCAttrRefB) {
- aCAttrB->setAttr(anIt->second);
- isProcessed = true;
+ AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ theAttribute);
+ if (!aRefAttr.get())
+ return false;
+
+ // get shape of tangent object to the current
+ std::string aTangentAttr = SketchPlugin_Constraint::ENTITY_A();
+ if (aRefAttr->id() == SketchPlugin_Constraint::ENTITY_A())
+ aTangentAttr = SketchPlugin_Constraint::ENTITY_B();
+ AttributeRefAttrPtr aTangentRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
+ aFeature->attribute(aTangentAttr));
+ FeaturePtr aTangentFeature = ModelAPI_Feature::feature(aTangentRefAttr->object());
+
+ // get shape of the feature of the attribute
+ FeaturePtr anAttributeFeature = ModelAPI_Feature::feature(aRefAttr->object());
+ anAttributeFeature->execute(); // the modified value should be applyed to recompute shape
+ PointToRefsMap aPointToAttributeOrObject;
+ std::list<FeaturePtr> aFeatures;
+ aFeatures.push_back(anAttributeFeature);
+ ModelGeomAlgo_Point2D::getPointsIntersectedShape(aTangentFeature, aFeatures,
+ aPointToAttributeOrObject);
+ if (!aPointToAttributeOrObject.empty())
+ return true; // the attribute feature has a point of intersection, so we do not replace it
+
+ // get shape of the feature
+ aPointToAttributeOrObject.clear();
+ aFeatures.clear();
+ aFeatures.push_back(theFeature);
+ ModelGeomAlgo_Point2D::getPointsIntersectedShape(aTangentFeature, aFeatures,
+ aPointToAttributeOrObject);
+ if (!aPointToAttributeOrObject.empty()) {
+ std::set<ResultPtr> anEdgeShapes;
+ ModelGeomAlgo_Shape::shapesOfType(theFeature, GeomAPI_Shape::EDGE, anEdgeShapes);
+ if (!anEdgeShapes.empty()) {
+ ResultPtr aResult = *anEdgeShapes.begin();
+ if (aResult.get()) {
+ aRefAttr->setObject(aResult);
+ return true; // the attribute feature has a point of intersection, so we do not replace it
+ }
}
}
- return isProcessed;
-}
-
-bool SketchPlugin_Trim::isMacro() const
-{
- return true;
+ return false;
}
AISObjectPtr SketchPlugin_Trim::getAISObject(AISObjectPtr thePrevious)
{
+#ifdef DEBUG_TRIM_METHODS
+ std::cout << "SketchPlugin_Trim::getAISObject: " << data()->name() << std::endl;
+#endif
+
AISObjectPtr anAIS = thePrevious;
std::list<std::shared_ptr<GeomAPI_Shape> > aShapes;
return aBaseShape;
// point on feature
- AttributePoint2DPtr aPoint = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
+ AttributePoint2DPtr aPointAttr = std::dynamic_pointer_cast<GeomDataAPI_Point2D>(
data()->attribute(thePointAttributeId));
- std::shared_ptr<GeomAPI_Pnt2d> anAttributePnt2d = aPoint->pnt();
+ std::shared_ptr<GeomAPI_Pnt2d> anAttributePnt2d = aPointAttr->pnt();
std::shared_ptr<GeomAPI_Pnt> anAttributePnt = sketch()->to3D(anAttributePnt2d->x(),
anAttributePnt2d->y());
}
}
-void SketchPlugin_Trim::getConstraints(std::set<FeaturePtr>& theFeaturesToDelete)
+void SketchPlugin_Trim::getConstraints(std::set<FeaturePtr>& theFeaturesToDelete,
+ std::set<FeaturePtr>& theFeaturesToUpdate)
{
std::shared_ptr<ModelAPI_Data> aData = data();
std::set<AttributePtr>::const_iterator aIt;
for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
- std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
- FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
+ std::shared_ptr<ModelAPI_Attribute> anAttr = (*aIt);
+ FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(anAttr->owner());
std::string aRefFeatureKind = aRefFeature->getKind();
- if (aRefFeatureKind == SketchPlugin_ConstraintMirror::ID() ||
- aRefFeatureKind == SketchPlugin_MultiRotation::ID() ||
- aRefFeatureKind == SketchPlugin_MultiTranslation::ID() ||
+ std::string anAttributeId = anAttr->id();
+ if ((aRefFeatureKind == SketchPlugin_ConstraintMirror::ID() &&
+ anAttributeId == SketchPlugin_ConstraintMirror::MIRROR_LIST_ID()) ||
+ (aRefFeatureKind == SketchPlugin_MultiRotation::ID() &&
+ anAttributeId == SketchPlugin_MultiRotation::ROTATION_LIST_ID()) ||
+ (aRefFeatureKind == SketchPlugin_MultiTranslation::ID() &&
+ anAttributeId == SketchPlugin_MultiTranslation::TRANSLATION_LIST_ID()) ||
aRefFeatureKind == SketchPlugin_ConstraintMiddle::ID())
theFeaturesToDelete.insert(aRefFeature);
+ else if (aRefFeatureKind == SketchPlugin_ConstraintLength::ID())
+ theFeaturesToUpdate.insert(aRefFeature);
}
}
}
}
-/*void SketchPlugin_Trim::getCoincidencesToObject(const ObjectPtr& theObject,
- std::map<AttributePtr, FeaturePtr>& theCoincidencesToBaseFeature)
-{
- const std::set<AttributePtr>& aRefsList = theObject->data()->refsToMe();
- std::set<AttributePtr>::const_iterator aIt;
- for (aIt = aRefsList.cbegin(); aIt != aRefsList.cend(); ++aIt) {
- std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
- FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
- if (aRefFeature->getKind() != SketchPlugin_ConstraintCoincidence::ID())
- continue;
- AttributePtr anAttribute;
- AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>
- (aRefFeature->attribute(SketchPlugin_Constraint::ENTITY_A()));
- if (aRefAttr->isObject() && aRefAttr->object() == theObject)
- {
- anAttribute = aRefFeature->attribute(SketchPlugin_Constraint::ENTITY_B());
- }
- else {
- AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>
- (aRefFeature->attribute(SketchPlugin_Constraint::ENTITY_B()));
- if (aRefAttr->isObject() && aRefAttr->object() == theObject)
- anAttribute = aRefFeature->attribute(SketchPlugin_Constraint::ENTITY_A());
- }
- if (!anAttribute.get())
- continue;
-
- aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(anAttribute);
- if (aRefAttr->isObject())
- continue; // one of attributes of coincidence contains link to an attribute
-
- anAttribute = aRefAttr->attr();
- if (anAttribute.get())
- {
- theCoincidencesToBaseFeature[anAttribute] = aRefFeature;
- }
- }
-}*/
-
void SketchPlugin_Trim::updateRefAttConstraints(
const std::map<AttributePtr, std::list<AttributePtr> >& theBaseRefAttributes,
const std::set<std::pair<AttributePtr, AttributePtr> >& theModifiedAttributes,
}
}
+#ifdef DEBUG_TRIM
// delete constraints
+ if (aFeaturesToDelete.size() > 0) {
+ std::cout << "removeReferencesToAttribute: " << std::endl;
+ std::string aValue;
+ for (std::set<FeaturePtr>::const_iterator anIt = aFeaturesToDelete.begin();
+ anIt != aFeaturesToDelete.end(); anIt++) {
+ FeaturePtr aFeature = *anIt;
+ std::cout << aFeature->data()->name() << std::endl;
+ }
+ }
+#endif
ModelAPI_Tools::removeFeaturesAndReferences(aFeaturesToDelete);
Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
}
-void SketchPlugin_Trim::trimLine(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+void SketchPlugin_Trim::updateFeaturesAfterTrim(const std::set<FeaturePtr>& theFeaturesToUpdate)
+{
+ std::set<FeaturePtr>::const_iterator anIt = theFeaturesToUpdate.begin(),
+ aLast = theFeaturesToUpdate.end();
+ for (; anIt != aLast; anIt++) {
+ FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(*anIt);
+ std::string aRefFeatureKind = aRefFeature->getKind();
+ if (aRefFeatureKind == SketchPlugin_ConstraintLength::ID()) {
+ std::shared_ptr<SketchPlugin_ConstraintLength> aLenghtFeature =
+ std::dynamic_pointer_cast<SketchPlugin_ConstraintLength>(*anIt);
+ if (aLenghtFeature.get()) {
+ std::shared_ptr<ModelAPI_AttributeDouble> aValueAttr = std::dynamic_pointer_cast<
+ ModelAPI_AttributeDouble>(aLenghtFeature->attribute(SketchPlugin_Constraint::VALUE()));
+ double aValue;
+ if (aLenghtFeature->computeLenghtValue(aValue) && aValueAttr.get())
+ aValueAttr->setValue(aValue);
+ }
+ }
+ }
+}
+
+FeaturePtr SketchPlugin_Trim::trimLine(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
std::map<AttributePtr, std::list<AttributePtr> >& theBaseRefAttributes,
std::set<AttributePoint2DPtr>& thePoints,
std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes)
{
+ FeaturePtr anNewFeature;
+
// Check the base objects are initialized.
AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
data()->attribute(SketchPlugin_Trim::SELECTED_OBJECT()));
// result is two lines: start line point - start shape point,
// last shape point - last line point
// create second line
- FeaturePtr anNewFeature = createLineFeature(aBaseFeature, aLastShapePoint, aLastFeaturePoint);
+ anNewFeature = createLineFeature(aBaseFeature, aLastShapePoint, aLastFeaturePoint);
thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
(anNewFeature->attribute(SketchPlugin_Line::START_ID())));
(aBaseFeature->attribute(aModifiedAttribute)));
// Collinear constraint for lines
- createConstraintForObjects(SketchPlugin_ConstraintCollinear::ID(),
- getFeatureResult(aBaseFeature),
- getFeatureResult(anNewFeature));
-
+ SketchPlugin_Tools::createConstraintObjectObject(sketch(),
+ SketchPlugin_ConstraintCollinear::ID(),
+ getFeatureResult(aBaseFeature),
+ getFeatureResult(anNewFeature));
}
+ return anNewFeature;
}
-void SketchPlugin_Trim::trimArc(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
+FeaturePtr SketchPlugin_Trim::trimArc(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
const std::shared_ptr<GeomAPI_Pnt2d>& theLastShapePoint,
std::map<AttributePtr, std::list<AttributePtr> >& theBaseRefAttributes,
std::set<AttributePoint2DPtr>& thePoints,
std::set<std::pair<AttributePtr, AttributePtr>>& theModifiedAttributes)
{
+ FeaturePtr anNewFeature;
// Check the base objects are initialized.
AttributeReferencePtr aBaseObjectAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(
data()->attribute(SketchPlugin_Trim::SELECTED_OBJECT()));
else {
// result is two arcs: start arc point - start shape point, last shape point - last arc point
// create second arc
- FeaturePtr anArcFeature = createArcFeature(aBaseFeature, aLastShapePoint, aLastArcPoint);
+ anNewFeature = createArcFeature(aBaseFeature, aLastShapePoint, aLastArcPoint);
thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
- (anArcFeature->attribute(SketchPlugin_Arc::START_ID())));
+ (anNewFeature->attribute(SketchPlugin_Arc::START_ID())));
std::string aModifiedAttribute = SketchPlugin_Arc::END_ID();
theModifiedAttributes.insert(
std::make_pair(aBaseFeature->attribute(aModifiedAttribute),
- anArcFeature->attribute(SketchPlugin_Arc::END_ID())));
+ anNewFeature->attribute(SketchPlugin_Arc::END_ID())));
// modify base arc
fillPointAttribute(aBaseFeature->attribute(aModifiedAttribute), aStartShapePoint);
(aBaseFeature->attribute(aModifiedAttribute)));
// equal Radius constraint for arcs
- anArcFeature->execute(); // we need the created arc result to set equal constraint
- createConstraintForObjects(SketchPlugin_ConstraintEqual::ID(),
- getFeatureResult(aBaseFeature),
- getFeatureResult(anArcFeature));
+ SketchPlugin_Tools::createConstraintObjectObject(sketch(),
+ SketchPlugin_ConstraintEqual::ID(),
+ getFeatureResult(aBaseFeature),
+ getFeatureResult(anNewFeature));
// coincident centers constraint
- createConstraint(SketchPlugin_ConstraintCoincidence::ID(),
- aBaseFeature->attribute(SketchPlugin_Arc::CENTER_ID()),
- anArcFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
+ SketchPlugin_Tools::createConstraintAttrAttr(sketch(),
+ SketchPlugin_ConstraintCoincidence::ID(),
+ aBaseFeature->attribute(SketchPlugin_Arc::CENTER_ID()),
+ anNewFeature->attribute(SketchPlugin_Arc::CENTER_ID()));
+#ifdef DEBUG_TRIM
std::cout << "Created arc on points:" << std::endl;
std::cout << "Start shape point: [" << aStartShapePoint->x() << ", " <<
aStartShapePoint->y() << "]" << std::endl;
-
+#endif
}
+ return anNewFeature;
}
FeaturePtr SketchPlugin_Trim::trimCircle(const std::shared_ptr<GeomAPI_Pnt2d>& theStartShapePoint,
//getFeaturePoints(aBaseFeature, aStartPointAttrOfBase, anEndPointAttrOfBase);
/// trim feature
- FeaturePtr anArcFeature = createArcFeature(aBaseFeature, theStartShapePoint, theLastShapePoint);
+ FeaturePtr anNewFeature = createArcFeature(aBaseFeature, theStartShapePoint, theLastShapePoint);
// arc created by trim of circle is always correct, that means that it is not inversed
- anArcFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->setValue(false);
+ anNewFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->setValue(false);
theModifiedAttributes.insert(
std::make_pair(aBaseFeature->attribute(SketchPlugin_Circle::CENTER_ID()),
- anArcFeature->attribute(SketchPlugin_Arc::CENTER_ID())));
+ anNewFeature->attribute(SketchPlugin_Arc::CENTER_ID())));
thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
- (anArcFeature->attribute(SketchPlugin_Arc::START_ID())));
+ (anNewFeature->attribute(SketchPlugin_Arc::START_ID())));
thePoints.insert(std::dynamic_pointer_cast<GeomDataAPI_Point2D>
- (anArcFeature->attribute(SketchPlugin_Arc::END_ID())));
+ (anNewFeature->attribute(SketchPlugin_Arc::END_ID())));
- return anArcFeature;
+ return anNewFeature;
}
void SketchPlugin_Trim::arrangePointsOnLine(const AttributePoint2DPtr& theStartPointAttr,
if (aModifiedAttribute.get() && aSourceAttribute.get())
aModifiedAttribute->setValue(aSourceAttribute->value());
}
- else if (anAttributeType == ModelAPI_AttributeRefAttr::typeId()) {
- AttributeRefAttrPtr aRefAttributeToFill = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- theModifiedAttribute);
- AttributeRefAttrPtr aSourceRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- theSourceAttribute);
- if (!aSourceRefAttr.get())
- aRefAttributeToFill->setAttr(theSourceAttribute);
- else {
- if (aSourceRefAttr->isObject())
- aRefAttributeToFill->setObject(aSourceRefAttr->object());
- else
- aRefAttributeToFill->setAttr(aSourceRefAttr->attr());
- }
- }
}
FeaturePtr SketchPlugin_Trim::createLineFeature(const FeaturePtr& theBaseFeature,
bool aReversed = theBaseFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->value();
aFeature->boolean(SketchPlugin_Arc::REVERSED_ID())->setValue(aReversed);
}
- //aFeature->execute(); // to obtain result
+ aFeature->execute(); // to obtain result (need to calculate arc parameters before sending Update)
aFeature->data()->blockSendAttributeUpdated(aWasBlocked);
#ifdef DEBUG_TRIM
return aFeature;
}
-FeaturePtr SketchPlugin_Trim::createConstraint(const std::string& theConstraintId,
- const AttributePtr& theFirstAttribute,
- const AttributePtr& theSecondAttribute)
-{
- FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
- AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
- aRefAttr->setAttr(theFirstAttribute);
-
- aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
- aRefAttr->setAttr(theSecondAttribute);
-
-#ifdef DEBUG_TRIM
- std::cout << "<createConstraint to attribute> :"
- << "first attribute - " << theFirstAttribute->id()
- << "second attribute - " << theSecondAttribute->id()
- << std::endl;
-#endif
-
- return aConstraint;
-}
-
-FeaturePtr SketchPlugin_Trim::createConstraintToObject(const std::string& theConstraintId,
- const AttributePtr& theFirstAttribute,
- const ObjectPtr& theSecondObject)
-{
- FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
- AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
- aRefAttr->setAttr(theFirstAttribute);
-
- aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
- aRefAttr->setObject(theSecondObject);
-
-#ifdef DEBUG_TRIM
- std::cout << "<createConstraint to attribute> :"
- << "first attribute - " << theFirstAttribute->id()
- << "second object - " << ModelAPI_Feature::feature(theSecondObject)->getKind()
- << std::endl;
-#endif
-
- return aConstraint;
-}
-
-FeaturePtr SketchPlugin_Trim::createConstraintForObjects(
- const std::string& theConstraintId,
- const ObjectPtr& theFirstObject,
- const ObjectPtr& theSecondObject)
-{
- FeaturePtr aConstraint = sketch()->addFeature(theConstraintId);
- AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A()));
- aRefAttr->setObject(theFirstObject);
-
- aRefAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(
- aConstraint->attribute(SketchPlugin_Constraint::ENTITY_B()));
- aRefAttr->setObject(theSecondObject);
-
- return aConstraint;
-}
-
std::shared_ptr<ModelAPI_Result> SketchPlugin_Trim::getFeatureResult(
const std::shared_ptr<ModelAPI_Feature>& theFeature)
{
ModelGeomAlgo_Point2D::getPointsOfReference(aFeature, SketchPlugin_ConstraintCoincidence::ID(),
aRefAttributes, SketchPlugin_Point::ID(), SketchPlugin_Point::COORD_ID());
// layed on feature coincidences to divide it on several shapes
- //SketchPlugin_Sketch* aSketch = sketch();
std::shared_ptr<ModelAPI_Data> aData = theSketch->data();
std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
aData->attribute(SketchPlugin_Sketch::ORIGIN_ID()));
std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(theSketch);
for (int i = 0; i < aSketchComposite->numberOfSubs(); i++) {
FeaturePtr aFeature = aSketchComposite->subFeature(i);
- if (aFeature.get())
+ if (aFeature.get() && aFeature->getKind() != SketchPlugin_Projection::ID())
aFeatures.push_back(aFeature);
}
ModelGeomAlgo_Point2D::getPointsIntersectedShape(aFeature, aFeatures, aPointsInfo);
