X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSketcherPrs%2FSketcherPrs_Tools.cpp;h=ad33dbe9b679b8bfdec974128df93320f4a10021;hb=54722f01656c4e5c67a3cdc04aa57ef614b6a446;hp=47468899ec7d2d7685b561f1277707b93d5c7bd8;hpb=ed3006032ada5642cbd0b1152c01170c815526a6;p=modules%2Fshaper.git diff --git a/src/SketcherPrs/SketcherPrs_Tools.cpp b/src/SketcherPrs/SketcherPrs_Tools.cpp index 47468899e..ad33dbe9b 100644 --- a/src/SketcherPrs/SketcherPrs_Tools.cpp +++ b/src/SketcherPrs/SketcherPrs_Tools.cpp @@ -10,30 +10,69 @@ #include #include #include +#include #include #include +#include +#include + +#include #include #include +#include +#include +#include + +#include + +#include +#include + +#include + +// it is not possible to use 0x2211 as summ symbol because it is not supported by +// debian Linux platform +static const Standard_ExtCharacter MyEmptySymbol(' '); +static const Standard_ExtCharacter MySigmaSymbol('=');//0x03A3); // using equal instead of sigma namespace SketcherPrs_Tools { -ObjectPtr getResult(ModelAPI_Feature* theFeature, const std::string& theAttrName) +AttributePtr getAttribute(ModelAPI_Feature* theFeature, const std::string& theAttrName) { - std::shared_ptr aData = theFeature->data(); - std::shared_ptr anAttr = - std::dynamic_pointer_cast(aData->attribute(theAttrName)); + AttributePtr anAttribute; + if (theFeature) { + std::shared_ptr aData = theFeature->data(); + if (aData.get() && aData->isValid()) { /// essential check as it is called in openGl thread + std::shared_ptr anAttr = aData->refattr(theAttrName); + if (!anAttr->isObject()) + anAttribute = anAttr->attr(); + } + } + return anAttribute; +} - return anAttr->object(); +ObjectPtr getResult(ModelAPI_Feature* theFeature, const std::string& theAttrName) +{ + ObjectPtr anObject; + if (theFeature) { + std::shared_ptr aData = theFeature->data(); + if (aData.get() && aData->isValid()) { /// essential check as it is called in openGl thread + std::shared_ptr anAttr = aData->refattr(theAttrName); + if (anAttr.get()) + anObject = anAttr->object(); + } + } + return anObject; } std::shared_ptr getShape(ObjectPtr theObject) { ResultConstructionPtr aRes = std::dynamic_pointer_cast(theObject); - if (aRes.get() != NULL) { + if (aRes.get() != NULL && aRes->data()->isValid()) {/// essential check as it is called in openGl thread return aRes->shape(); } return std::shared_ptr(); @@ -45,23 +84,22 @@ std::shared_ptr getPoint(ModelAPI_Feature* theFeature, { std::shared_ptr aPointAttr; - if (!theFeature->data()) + /// essential check as it is called in openGl thread + if (!theFeature || !theFeature->data().get() || !theFeature->data()->isValid()) return std::shared_ptr(); FeaturePtr aFeature; std::shared_ptr anAttr = std::dynamic_pointer_cast< ModelAPI_AttributeRefAttr>(theFeature->data()->attribute(theAttribute)); - if (anAttr) - aFeature = ModelAPI_Feature::feature(anAttr->object()); + if(!anAttr.get()) { + return std::shared_ptr(); + } + aFeature = ModelAPI_Feature::feature(anAttr->object()); if (aFeature && aFeature->getKind() == SketchPlugin_Point::ID()) aPointAttr = std::dynamic_pointer_cast( aFeature->data()->attribute(SketchPlugin_Point::COORD_ID())); - else if (aFeature && aFeature->getKind() == SketchPlugin_Circle::ID()) - aPointAttr = std::dynamic_pointer_cast( - aFeature->data()->attribute(SketchPlugin_Circle::CENTER_ID())); - else if (anAttr->attr()) { aPointAttr = std::dynamic_pointer_cast(anAttr->attr()); } @@ -70,31 +108,88 @@ std::shared_ptr getPoint(ModelAPI_Feature* theFeature, return std::shared_ptr(); } +//************************************************************************************* +/// Find an attribute of the given object which corresponds to a vetrex +/// defined by a shape +/// \param theObject an object +/// \param theShape a vertex +/// \param thePlane a projection plane (sketcher plane) +std::shared_ptr findGeomPoint(ObjectPtr theObject, + const TopoDS_Shape& theShape, + const std::shared_ptr& thePlane) +{ + std::shared_ptr aGeomPoint; + + FeaturePtr anObjectFeature = ModelAPI_Feature::feature(theObject); + if (anObjectFeature) { + if (theShape.ShapeType() == TopAbs_VERTEX) { + const TopoDS_Vertex& aShapeVertex = TopoDS::Vertex(theShape); + if (!aShapeVertex.IsNull()) { + gp_Pnt aShapePoint = BRep_Tool::Pnt(aShapeVertex); + std::shared_ptr aShapeGeomPnt = std::shared_ptr( + new GeomAPI_Pnt(aShapePoint.X(), aShapePoint.Y(), aShapePoint.Z())); + + // find the given point in the feature attributes + std::list anObjectAttiributes = + anObjectFeature->data()->attributes(GeomDataAPI_Point2D::typeId()); + std::list::const_iterator anIt = anObjectAttiributes.begin(), + aLast = anObjectAttiributes.end(); + for (; anIt != aLast && !aGeomPoint; anIt++) { + std::shared_ptr anAttributePoint = + std::dynamic_pointer_cast(*anIt); + + std::shared_ptr anAttributePnt = thePlane->to3D(anAttributePoint->x(), + anAttributePoint->y()); + if (anAttributePnt.get() && + anAttributePnt->distance(aShapeGeomPnt) < Precision::Confusion()) { + aGeomPoint = anAttributePoint; + break; + } + } + } + } + } + return aGeomPoint; +} + //************************************************************************************* std::shared_ptr getFeaturePoint(DataPtr theData, - const std::string& theAttribute) + const std::string& theAttribute, + const std::shared_ptr& thePlane) { std::shared_ptr aPointAttr; - if (!theData) + if (!theData.get() || !theData->isValid()) /// essential check as it is called in openGl thread return aPointAttr; FeaturePtr aFeature; std::shared_ptr anAttr = std::dynamic_pointer_cast< ModelAPI_AttributeRefAttr>(theData->attribute(theAttribute)); - if (anAttr) - aFeature = ModelAPI_Feature::feature(anAttr->object()); - - if (aFeature && aFeature->getKind() == SketchPlugin_Point::ID()) - aPointAttr = std::dynamic_pointer_cast( - aFeature->data()->attribute(SketchPlugin_Point::COORD_ID())); - - else if (aFeature && aFeature->getKind() == SketchPlugin_Circle::ID()) - aPointAttr = std::dynamic_pointer_cast( - aFeature->data()->attribute(SketchPlugin_Circle::CENTER_ID())); - - else if (anAttr->attr()) { - aPointAttr = std::dynamic_pointer_cast(anAttr->attr()); + if (anAttr) { + if (anAttr->isObject()) { + ObjectPtr anObject = anAttr->object(); + aFeature = ModelAPI_Feature::feature(anObject); + if (aFeature && aFeature->getKind() == SketchPlugin_Point::ID()) { + // Attribute refers to a point + aPointAttr = std::dynamic_pointer_cast( + aFeature->data()->attribute(SketchPlugin_Point::COORD_ID())); + } + else { + // if the attribute refers on another object + ResultPtr aRes = std::dynamic_pointer_cast(anObject); + if (aRes.get()) { + GeomShapePtr aShape = aRes->shape(); + if (aShape.get()) { + TopoDS_Shape aTDSShape = aShape->impl(); + aPointAttr = findGeomPoint(anObject, aTDSShape, thePlane); + } + } + } + } + else if (anAttr->attr()) { + // If attribute is a point + aPointAttr = std::dynamic_pointer_cast(anAttr->attr()); + } } return aPointAttr; } @@ -104,7 +199,7 @@ FeaturePtr getFeatureLine(DataPtr theData, const std::string& theAttribute) { FeaturePtr aLine; - if (!theData) + if (!theData.get() || !theData->isValid()) /// essential check as it is called in openGl thread) return aLine; std::shared_ptr anAttr = @@ -123,6 +218,9 @@ std::shared_ptr getProjectionPoint(const FeaturePtr theLine, const std::shared_ptr& thePoint) { DataPtr aData = theLine->data(); + if (!aData.get() || !aData->isValid()) + return std::shared_ptr(); + std::shared_ptr aPoint1 = std::dynamic_pointer_cast( aData->attribute(SketchPlugin_Line::START_ID())); std::shared_ptr aPoint2 = std::dynamic_pointer_cast( @@ -133,7 +231,7 @@ std::shared_ptr getProjectionPoint(const FeaturePtr theLine, } -static double MyArrowSize = 30.; +static double MyArrowSize = 20; double getArrowSize() { return MyArrowSize; @@ -144,4 +242,143 @@ void setArrowSize(double theSize) MyArrowSize = theSize; } +int getDefaultArrowSize() +{ + return 20; +} + +static double MyTextHeight = 16; +double getTextHeight() +{ + return MyTextHeight; +} + +void setTextHeight(double theHeight) +{ + MyTextHeight = theHeight; +} + +double getDefaultTextHeight() +{ + return 16; +} + +double getFlyoutDistance(const ModelAPI_Feature* theConstraint) +{ + std::shared_ptr aFlyoutPoint = + std::dynamic_pointer_cast( + const_cast(theConstraint)->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT())); + + return aFlyoutPoint->y(); +} + +std::shared_ptr getAnchorPoint(const ModelAPI_Feature* theConstraint, + const std::shared_ptr& thePlane) +{ + ModelAPI_Feature* aConstraint = const_cast(theConstraint); + AttributeRefAttrPtr aRefAttr = std::dynamic_pointer_cast( + aConstraint->attribute(SketchPlugin_Constraint::ENTITY_A())); + if (!aRefAttr || !aRefAttr->isObject() || !aRefAttr->object()) + return std::shared_ptr(); + + FeaturePtr aFeature = ModelAPI_Feature::feature(aRefAttr->object()); + std::shared_ptr aCenter; + if (aFeature->getKind() == SketchPlugin_Arc::ID()) { // arc + aCenter = std::dynamic_pointer_cast( + aFeature->attribute(SketchPlugin_Arc::CENTER_ID()))->pnt(); + } else if (aFeature->getKind() == SketchPlugin_Circle::ID()) { // circle + aCenter = std::dynamic_pointer_cast( + aFeature->attribute(SketchPlugin_Circle::CENTER_ID()))->pnt(); + } else + return std::shared_ptr(); + + std::shared_ptr anOrigin(new GeomAPI_Pnt2d(0.0, 0.0)); + std::shared_ptr aFlyoutPnt = std::dynamic_pointer_cast( + aConstraint->attribute(SketchPlugin_Constraint::FLYOUT_VALUE_PNT()))->pnt(); + double aRadius = std::dynamic_pointer_cast( + aConstraint->attribute(SketchPlugin_Constraint::VALUE()))->value(); + double aLen = aFlyoutPnt->distance(anOrigin); + aRadius *= 1.001; // a gap to make point much closer to the circle, but not lying on it + aFlyoutPnt->setX(aCenter->x() + aFlyoutPnt->x() * aRadius / aLen); + aFlyoutPnt->setY(aCenter->y() + aFlyoutPnt->y() * aRadius / aLen); + return thePlane->to3D(aFlyoutPnt->x(), aFlyoutPnt->y()); +} + +void setDisplaySpecialSymbol(AIS_Dimension* theDimension, const bool& theToDisplay) +{ + if (theToDisplay) { + theDimension->SetSpecialSymbol(MySigmaSymbol); + theDimension->SetDisplaySpecialSymbol(AIS_DSS_Before); + } + else { + theDimension->SetSpecialSymbol(MyEmptySymbol); + theDimension->SetDisplaySpecialSymbol(AIS_DSS_No); + } +} + +void setDisplayParameter(AIS_Dimension* theDimension, const std::string& theParameter, + const bool& theToDisplay) +{ + if (theToDisplay) { + theDimension->DimensionAspect()->MakeUnitsDisplayed(true); + theDimension->SetDisplayUnits(TCollection_AsciiString(theParameter.c_str())); + theDimension->DimensionAspect()->SetValueStringFormat(""); + } + else { + theDimension->DimensionAspect()->MakeUnitsDisplayed(false); + theDimension->SetDisplayUnits(TCollection_AsciiString()); // THE_UNDEFINED_UNITS in AIS_Dimension + theDimension->DimensionAspect()->SetValueStringFormat("%g"); + } +} + +void sendExpressionShownEvent(const bool& theState) +{ + static Events_ID anId = SketcherPrs_ParameterStyleMessage::eventId(); + std::shared_ptr aMessage = std::shared_ptr + (new SketcherPrs_ParameterStyleMessage(anId, 0)); + aMessage->setStyle(theState ? SketcherPrs_ParameterStyleMessage::ParameterText + : SketcherPrs_ParameterStyleMessage::ParameterValue); + Events_Loop::loop()->send(aMessage); + Events_Loop::loop()->flush(anId); +} + +Handle(Prs3d_DimensionAspect) createDimensionAspect() +{ + Handle(Prs3d_DimensionAspect) anAspect = new Prs3d_DimensionAspect(); + anAspect->MakeArrows3d(false); + anAspect->MakeText3d(false); + anAspect->MakeTextShaded(false); + anAspect->MakeUnitsDisplayed(false); + anAspect->TextAspect()->SetHeight(SketcherPrs_Tools::getDefaultTextHeight()); + anAspect->ArrowAspect()->SetLength(SketcherPrs_Tools::getArrowSize()); + + return anAspect; +} + +void updateArrows(Handle(Prs3d_DimensionAspect) theDimAspect, double theDimValue, double theTextSize) +{ + double anArrowLength = theDimAspect->ArrowAspect()->Length(); + // This is not realy correct way to get viewer scale. + double aViewerScale = (double) SketcherPrs_Tools::getDefaultArrowSize() / anArrowLength; + + if(theTextSize > ((theDimValue - 3 * SketcherPrs_Tools::getArrowSize()) * aViewerScale)) { + theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Left); + theDimAspect->SetArrowOrientation(Prs3d_DAO_External); + theDimAspect->SetExtensionSize(theTextSize / aViewerScale - SketcherPrs_Tools::getArrowSize() / 2.0); + } else { + theDimAspect->SetTextHorizontalPosition(Prs3d_DTHP_Center); + theDimAspect->SetArrowOrientation(Prs3d_DAO_Internal); + } + theDimAspect->SetArrowTailSize(theDimAspect->ArrowAspect()->Length()); + // The value of vertical aligment is sometimes changed + theDimAspect->TextAspect()->SetVerticalJustification(Graphic3d_VTA_CENTER); +} + +void sendEmptyPresentationError(ModelAPI_Feature* theFeature, const std::string theError) +{ + Events_Error::throwException("An empty AIS presentation: SketcherPrs_LengthDimension"); + static const Events_ID anEvent = Events_Loop::eventByName(EVENT_EMPTY_AIS_PRESENTATION); + std::shared_ptr aConstraintPtr(theFeature); + ModelAPI_EventCreator::get()->sendUpdated(aConstraintPtr, anEvent); +} };