src/SketchPlugin/Test/TestConstraintTangent.py

   1 """
   2     TestConstraintTangent.py
   3     Unit test of SketchPlugin_ConstraintTangent class
   4
   5     SketchPlugin_ConstraintTangent
   6         static const std::string MY_CONSTRAINT_TANGENT_ID("SketchConstraintTangent");
   7         data()->addAttribute(SketchPlugin_Constraint::ENTITY_A(), ModelAPI_AttributeRefAttr::typeId());
   8         data()->addAttribute(SketchPlugin_Constraint::ENTITY_B(), ModelAPI_AttributeRefAttr::typeId());
   9
  10 """
  11 from GeomDataAPI import *
  12 from GeomAPI import *
  13 from ModelAPI import *
  14 import math
  15 from salome.shaper import model
  16
  17 #=========================================================================
  18 # Initialization of the test
  19 #=========================================================================
  20
  21 __updated__ = "2015-03-17"
  22
  23 def distancePointPoint(thePoint1, thePoint2):
  24     """
  25     subroutine to calculate distance between two points
  26     result of calculated distance is has 10**-5 precision
  27     """
  28     aDist = math.sqrt((thePoint1.x()-thePoint2.x())**2 + (thePoint1.y()-thePoint2.y())**2)
  29     return round(aDist, 5)
  30
  31 def distancePointLine(point, line):
  32     """
  33     subroutine to calculate distance between point and line
  34     result of calculated distance is has 10**-5 precision
  35     """
  36     aStartPoint = geomDataAPI_Point2D(line.attribute("StartPoint"))
  37     aEndPoint = geomDataAPI_Point2D(line.attribute("EndPoint"))
  38     # orthogonal direction
  39     aDirX = -(aEndPoint.y() - aStartPoint.y())
  40     aDirY = (aEndPoint.x() - aStartPoint.x())
  41     aLen = math.sqrt(aDirX**2 + aDirY**2)
  42     aDirX = aDirX / aLen
  43     aDirY = aDirY / aLen
  44     aVecX = point.x() - aStartPoint.x()
  45     aVecY = point.y() - aStartPoint.y()
  46     return round(math.fabs(aVecX * aDirX + aVecY * aDirY), 5)
  47
  48 def checkArcLineTangency(theArc, theLine):
  49     """
  50     subroutine to check that the line is tangent to arc/circle
  51     """
  52     if (theArc.getKind() == "SketchCircle"):
  53         aCenter = geomDataAPI_Point2D(theArc.attribute("CircleCenter"))
  54         aRadius = theArc.real("CircleRadius").value()
  55     else:
  56         aCenter = geomDataAPI_Point2D(theArc.attribute("ArcCenter"))
  57         aStartPnt = geomDataAPI_Point2D(theArc.attribute("ArcStartPoint"))
  58         aRadius = distancePointPoint(aStartPnt, aCenter)
  59     aDist = distancePointLine(aCenter, theLine)
  60     assert math.fabs(aDist - aRadius) < 2.e-5, "aDist = {0}, aRadius = {1}".format(aDist, aRadius)
  61
  62 def checkArcArcTangency(theArc1, theArc2):
  63     """
  64     subroutine to check that arcs/circles arc tangent
  65     """
  66     anArcs = [theArc1, theArc2]
  67     aCenters = []
  68     aRadii = []
  69     for anArc in anArcs:
  70         if (anArc.getKind() == "SketchCircle"):
  71             aCenter = geomDataAPI_Point2D(anArc.attribute("CircleCenter"))
  72             aRadius = anArc.real("CircleRadius").value()
  73         else:
  74             aCenter = geomDataAPI_Point2D(anArc.attribute("ArcCenter"))
  75             aStartPnt = geomDataAPI_Point2D(anArc.attribute("ArcStartPoint"))
  76             aRadius = distancePointPoint(aStartPnt, aCenter)
  77         aCenters.append(aCenter)
  78         aRadii.append(aRadius)
  79     aDist = distancePointPoint(aCenters[0], aCenters[1])
  80     aRSum = aRadii[0] + aRadii[1]
  81     aRDiff = math.fabs(aRadii[0] - aRadii[1])
  82     assert math.fabs(aDist - aRSum) < 2.e-5 or math.fabs(aDist - aRDiff) < 2.e-5, "aDist = {0}, aRSum = {1}, aRDiff = {2}".format(aDist, aRSum, aRDiff)
  83
  84
  85 aSession = ModelAPI_Session.get()
  86 aDocument = aSession.moduleDocument()
  87 #=========================================================================
  88 # Creation of a sketch
  89 #=========================================================================
  90 aSession.startOperation()
  91 aSketchCommonFeature = aDocument.addFeature("Sketch")
  92 aSketchFeature = featureToCompositeFeature(aSketchCommonFeature)
  93 origin = geomDataAPI_Point(aSketchFeature.attribute("Origin"))
  94 origin.setValue(0, 0, 0)
  95 dirx = geomDataAPI_Dir(aSketchFeature.attribute("DirX"))
  96 dirx.setValue(1, 0, 0)
  97 norm = geomDataAPI_Dir(aSketchFeature.attribute("Norm"))
  98 norm.setValue(0, 0, 1)
  99 aSession.finishOperation()
 100 #=========================================================================
 101 # TEST 1. Arc-line tangency
 102 #=========================================================================
 103 # Creation of an arc and two lines
 104 #=========================================================================
 105 # Arc
 106 aSession.startOperation()
 107 aSketchArc1 = aSketchFeature.addFeature("SketchArc")
 108 anArcCentr = geomDataAPI_Point2D(aSketchArc1.attribute("ArcCenter"))
 109 anArcCentr.setValue(10., 10.)
 110 anArcStartPoint = geomDataAPI_Point2D(aSketchArc1.attribute("ArcStartPoint"))
 111 anArcStartPoint.setValue(0., 50.)
 112 anArcEndPoint = geomDataAPI_Point2D(aSketchArc1.attribute("ArcEndPoint"))
 113 anArcEndPoint.setValue(50., 0.)
 114 aSession.finishOperation()
 115 # Line 1
 116 aSession.startOperation()
 117 aSketchLine1 = aSketchFeature.addFeature("SketchLine")
 118 aLine1StartPoint = geomDataAPI_Point2D(aSketchLine1.attribute("StartPoint"))
 119 aLine1EndPoint = geomDataAPI_Point2D(aSketchLine1.attribute("EndPoint"))
 120 aLine1StartPoint.setValue(0., 50.)
 121 aLine1EndPoint.setValue(0., 100.)
 122 aSession.finishOperation()
 123 # Line 2
 124 aSession.startOperation()
 125 aSketchLine2 = aSketchFeature.addFeature("SketchLine")
 126 aLine2StartPoint = geomDataAPI_Point2D(aSketchLine2.attribute("StartPoint"))
 127 aLine2EndPoint = geomDataAPI_Point2D(aSketchLine2.attribute("EndPoint"))
 128 aLine2StartPoint.setValue(50., 0.)
 129 aLine2EndPoint.setValue(100., 0.)
 130 aSession.finishOperation()
 131 assert (model.dof(aSketchFeature) == 13)
 132 #=========================================================================
 133 # Link arc points and lines points by the coincidence constraint
 134 #=========================================================================
 135 aSession.startOperation()
 136 aConstraint = aSketchFeature.addFeature("SketchConstraintCoincidence")
 137 reflistA = aConstraint.refattr("ConstraintEntityA")
 138 reflistB = aConstraint.refattr("ConstraintEntityB")
 139 reflistA.setAttr(anArcStartPoint)
 140 reflistB.setAttr(aLine1StartPoint)
 141 aConstraint.execute()
 142 aSession.finishOperation()
 143 aSession.startOperation()
 144 aConstraint = aSketchFeature.addFeature("SketchConstraintCoincidence")
 145 reflistA = aConstraint.refattr("ConstraintEntityA")
 146 reflistB = aConstraint.refattr("ConstraintEntityB")
 147 reflistA.setAttr(anArcEndPoint)
 148 reflistB.setAttr(aLine2StartPoint)
 149 aConstraint.execute()
 150 aSession.finishOperation()
 151 assert (model.dof(aSketchFeature) == 9)
 152 #=========================================================================
 153 # Add tangency constraint and check correctness
 154 #=========================================================================
 155 aSession.startOperation()
 156 aTangency = aSketchFeature.addFeature("SketchConstraintTangent")
 157 aRefObjectA = aTangency.refattr("ConstraintEntityA")
 158 aRefObjectB = aTangency.refattr("ConstraintEntityB")
 159 anObjectA = modelAPI_ResultConstruction(aSketchArc1.lastResult())
 160 anObjectB = modelAPI_ResultConstruction(aSketchLine1.lastResult())
 161 assert (anObjectA is not None)
 162 assert (anObjectB is not None)
 163 aRefObjectA.setObject(anObjectA)
 164 aRefObjectB.setObject(anObjectB)
 165 aTangency.execute()
 166 aSession.finishOperation()
 167 checkArcLineTangency(aSketchArc1, aSketchLine1)
 168 assert (model.dof(aSketchFeature) == 8)
 169 #=========================================================================
 170 # Add tangency constraint for arc and second line and check correctness
 171 #=========================================================================
 172 aSession.startOperation()
 173 aTangency = aSketchFeature.addFeature("SketchConstraintTangent")
 174 aRefObjectA = aTangency.refattr("ConstraintEntityA")
 175 aRefObjectB = aTangency.refattr("ConstraintEntityB")
 176 anObjectA = modelAPI_ResultConstruction(aSketchArc1.lastResult())
 177 anObjectB = modelAPI_ResultConstruction(aSketchLine2.lastResult())
 178 assert (anObjectA is not None)
 179 assert (anObjectB is not None)
 180 aRefObjectA.setObject(anObjectA)
 181 aRefObjectB.setObject(anObjectB)
 182 aTangency.execute()
 183 aSession.finishOperation()
 184 checkArcLineTangency(aSketchArc1, aSketchLine2)
 185 assert (model.dof(aSketchFeature) == 7)
 186
 187 #=========================================================================
 188 # TEST 2. Arc-arc tangency
 189 #=========================================================================
 190 # Creation of arcs
 191 #=========================================================================
 192 # Arc 1
 193 aSession.startOperation()
 194 aSketchArc1 = aSketchFeature.addFeature("SketchArc")
 195 anArc1Centr = geomDataAPI_Point2D(aSketchArc1.attribute("ArcCenter"))
 196 anArc1Centr.setValue(10., 10.)
 197 anArc1StartPoint = geomDataAPI_Point2D(aSketchArc1.attribute("ArcStartPoint"))
 198 anArc1StartPoint.setValue(50., 0.)
 199 anArc1EndPoint = geomDataAPI_Point2D(aSketchArc1.attribute("ArcEndPoint"))
 200 anArc1EndPoint.setValue(0., 50.)
 201 aSession.finishOperation()
 202 # Arc 2
 203 aSession.startOperation()
 204 aSketchArc2 = aSketchFeature.addFeature("SketchArc")
 205 aSketchArc2.string("ArcType").setValue("ThreePoints")
 206 anArc2Centr = geomDataAPI_Point2D(aSketchArc2.attribute("ArcCenter"))
 207 anArc2StartPoint = geomDataAPI_Point2D(aSketchArc2.attribute("ArcStartPoint"))
 208 anArc2StartPoint.setValue(0., 50.)
 209 anArc2EndPoint = geomDataAPI_Point2D(aSketchArc2.attribute("ArcEndPoint"))
 210 anArc2EndPoint.setValue(-50., 0.)
 211 anArc2PassedPoint = geomDataAPI_Point2D(aSketchArc2.attribute("ArcPassedPoint"))
 212 anArc2PassedPoint.setValue(-40., 40.)
 213 aSession.finishOperation()
 214 assert (model.dof(aSketchFeature) == 17)
 215 #=========================================================================
 216 # Link points of arcs by the coincidence constraint
 217 #=========================================================================
 218 aSession.startOperation()
 219 aConstraint = aSketchFeature.addFeature("SketchConstraintCoincidence")
 220 reflistA = aConstraint.refattr("ConstraintEntityA")
 221 reflistB = aConstraint.refattr("ConstraintEntityB")
 222 reflistA.setAttr(anArc1EndPoint)
 223 reflistB.setAttr(anArc2StartPoint)
 224 aConstraint.execute()
 225 aSession.finishOperation()
 226 assert (model.dof(aSketchFeature) == 15)
 227 #=========================================================================
 228 # Add tangency constraint and check correctness
 229 #=========================================================================
 230 aSession.startOperation()
 231 aTangency = aSketchFeature.addFeature("SketchConstraintTangent")
 232 aRefObjectA = aTangency.refattr("ConstraintEntityA")
 233 aRefObjectB = aTangency.refattr("ConstraintEntityB")
 234 anObjectA = modelAPI_ResultConstruction(aSketchArc1.lastResult())
 235 anObjectB = modelAPI_ResultConstruction(aSketchArc2.lastResult())
 236 assert (anObjectA is not None)
 237 assert (anObjectB is not None)
 238 aRefObjectA.setObject(anObjectA)
 239 aRefObjectB.setObject(anObjectB)
 240 aTangency.execute()
 241 aSession.finishOperation()
 242 checkArcArcTangency(aSketchArc1, aSketchArc2)
 243 assert (model.dof(aSketchFeature) == 14)
 244
 245 #=========================================================================
 246 # TEST 3. Tangency between non-connected objects should work
 247 #=========================================================================
 248 # 3.1 tangency between arc2 and line2
 249 aSession.startOperation()
 250 aTangency = aSketchFeature.addFeature("SketchConstraintTangent")
 251 aRefObjectA = aTangency.refattr("ConstraintEntityA")
 252 aRefObjectB = aTangency.refattr("ConstraintEntityB")
 253 anObjectA = modelAPI_ResultConstruction(aSketchArc2.lastResult())
 254 anObjectB = modelAPI_ResultConstruction(aSketchLine2.lastResult())
 255 assert (anObjectA is not None)
 256 assert (anObjectB is not None)
 257 aRefObjectA.setObject(anObjectA)
 258 aRefObjectB.setObject(anObjectB)
 259 aTangency.execute()
 260 aSession.finishOperation()
 261 checkArcLineTangency(aSketchArc2, aSketchLine2)
 262 assert (model.dof(aSketchFeature) == 13)
 263
 264 aSession.startOperation()
 265 aDocument.removeFeature(aTangency)
 266 aSession.finishOperation()
 267 assert (model.dof(aSketchFeature) == 14)
 268
 269 # 3.2  tangency between non-connected arcs
 270 aSession.startOperation()
 271 aSketchArc3 = aSketchFeature.addFeature("SketchArc")
 272 anArc3Centr = geomDataAPI_Point2D(aSketchArc3.attribute("ArcCenter"))
 273 anArc3Centr.setValue(100., -10.)
 274 anArc3StartPoint = geomDataAPI_Point2D(aSketchArc3.attribute("ArcStartPoint"))
 275 anArc3StartPoint.setValue(70., -10.)
 276 anArc3EndPoint = geomDataAPI_Point2D(aSketchArc3.attribute("ArcEndPoint"))
 277 anArc3EndPoint.setValue(100., 20.)
 278 aSession.finishOperation()
 279 assert (model.dof(aSketchFeature) == 19)
 280
 281 aSession.startOperation()
 282 aTangency = aSketchFeature.addFeature("SketchConstraintTangent")
 283 aTangency.refattr("ConstraintEntityA").setObject(modelAPI_ResultConstruction(aSketchArc2.lastResult()))
 284 aTangency.refattr("ConstraintEntityB").setObject(modelAPI_ResultConstruction(aSketchArc3.lastResult()))
 285 aSession.finishOperation()
 286 checkArcArcTangency(aSketchArc2, aSketchArc3)
 287 assert (model.dof(aSketchFeature) == 18)
 288
 289 aSession.startOperation()
 290 aDocument.removeFeature(aSketchArc3)
 291 aDocument.removeFeature(aTangency)
 292 aSession.finishOperation()
 293 assert (model.dof(aSketchFeature) == 14)
 294
 295 # 3.3  tangency between arc and circle
 296 aSession.startOperation()
 297 aCircle1 = aSketchFeature.addFeature("SketchCircle")
 298 aCircleCenter = geomDataAPI_Point2D(aCircle1.attribute("CircleCenter"))
 299 aCircleRadius = aCircle1.real("CircleRadius")
 300 aCircleCenter.setValue(150., 100.)
 301 aCircleRadius.setValue(50.)
 302 aSession.finishOperation()
 303 assert (model.dof(aSketchFeature) == 17)
 304
 305 aSession.startOperation()
 306 aTangency1 = aSketchFeature.addFeature("SketchConstraintTangent")
 307 aTangency1.refattr("ConstraintEntityA").setObject(modelAPI_ResultConstruction(aSketchArc2.lastResult()))
 308 aTangency1.refattr("ConstraintEntityB").setObject(modelAPI_ResultConstruction(aCircle1.lastResult()))
 309 aSession.finishOperation()
 310 checkArcArcTangency(aSketchArc2, aCircle1)
 311 assert (model.dof(aSketchFeature) == 16)
 312
 313 # 3.4  tangency between two circles
 314 aSession.startOperation()
 315 aCircle2 = aSketchFeature.addFeature("SketchCircle")
 316 aCircleCenter = geomDataAPI_Point2D(aCircle2.attribute("CircleCenter"))
 317 aCircleRadius = aCircle2.real("CircleRadius")
 318 aCircleCenter.setValue(120., 70.)
 319 aCircleRadius.setValue(20.)
 320 aSession.finishOperation()
 321 assert (model.dof(aSketchFeature) == 19)
 322
 323 aSession.startOperation()
 324 aTangency2 = aSketchFeature.addFeature("SketchConstraintTangent")
 325 aTangency2.refattr("ConstraintEntityA").setObject(modelAPI_ResultConstruction(aCircle1.lastResult()))
 326 aTangency2.refattr("ConstraintEntityB").setObject(modelAPI_ResultConstruction(aCircle2.lastResult()))
 327 aSession.finishOperation()
 328 checkArcArcTangency(aCircle1, aCircle2)
 329 assert (model.dof(aSketchFeature) == 18)
 330
 331 #=========================================================================
 332 # TEST 4. Creating of tangency arc by the option of the SketchArc feature
 333 #=========================================================================
 334 aSession.startOperation()
 335 aSketchArc3 = aSketchFeature.addFeature("SketchArc")
 336 aSketchArc3.string("ArcType").setValue("Tangent")
 337 anArc3Start = aSketchArc3.refattr("ArcTangentPoint")
 338 anArc3Start.setAttr(anArc1StartPoint)
 339 anArc3EndPoint = geomDataAPI_Point2D(aSketchArc3.attribute("ArcEndPoint"))
 340 anArc3EndPoint.setValue(anArc1StartPoint.x()-5, anArc1StartPoint.y()-30)
 341 aSession.finishOperation()
 342 checkArcArcTangency(aSketchArc1, aSketchArc3)
 343 # freeze radius of tangent arc
 344 aSession.startOperation()
 345 aConstraintRadius = aSketchFeature.addFeature("SketchConstraintRadius")
 346 aConstraintRadius.refattr("ConstraintEntityA").setObject(modelAPI_ResultConstruction(aSketchArc3.lastResult()))
 347 aConstraintRadius.real("ConstraintValue").setValue(30.)
 348 aSession.finishOperation()
 349 checkArcArcTangency(aSketchArc1, aSketchArc3)
 350 # do not check DoF here because it is unstable for tangent arcs,
 351 # remove tangent arc to avoid instability while dumping
 352 aSession.startOperation()
 353 ModelAPI.removeFeaturesAndReferences(FeatureSet([aSketchArc3]))
 354 aSession.finishOperation()
 355 assert (model.dof(aSketchFeature) == 18)
 356
 357 #=========================================================================
 358 # TEST 5. Creating of tangency between line and circle
 359 #=========================================================================
 360 aSession.startOperation()
 361 aLine = aSketchFeature.addFeature("SketchLine")
 362 aLineStart = geomDataAPI_Point2D(aLine.attribute("StartPoint"))
 363 aLineEnd = geomDataAPI_Point2D(aLine.attribute("EndPoint"))
 364 aLineStart.setValue(100., 100.)
 365 aLineEnd.setValue(200., 200.)
 366 aCircle = aSketchFeature.addFeature("SketchCircle")
 367 aCircleCenter = geomDataAPI_Point2D(aCircle.attribute("CircleCenter"))
 368 aCircleRadius = aCircle.real("CircleRadius")
 369 aCircleCenter.setValue(150., 100.)
 370 aCircleRadius.setValue(20.)
 371 aSession.finishOperation()
 372 assert (model.dof(aSketchFeature) == 25)
 373
 374 aSession.startOperation()
 375 aTangency = aSketchFeature.addFeature("SketchConstraintTangent")
 376 aRefObjectA = aTangency.refattr("ConstraintEntityA")
 377 aRefObjectB = aTangency.refattr("ConstraintEntityB")
 378 anObjectA = modelAPI_ResultConstruction(aLine.lastResult())
 379 anObjectB = modelAPI_ResultConstruction(aCircle.lastResult())
 380 assert (anObjectA is not None)
 381 assert (anObjectB is not None)
 382 aRefObjectA.setObject(anObjectA)
 383 aRefObjectB.setObject(anObjectB)
 384 aTangency.execute()
 385 aSession.finishOperation()
 386
 387 checkArcLineTangency(aCircle, aLine)
 388 assert (model.dof(aSketchFeature) == 24)
 389 #=========================================================================
 390 # End of test
 391 #=========================================================================
 392
 393 assert(model.checkPythonDump())