src/Bnd/Bnd_B3x.gxx

   1 // Created on: 2005-09-08
   2 // Created by: Alexander GRIGORIEV
   3 // Copyright (c) 2005-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 inline Standard_Boolean _compareDist  (const RealType aHSize[3],
  17                                        const RealType aDist [3])
  18 {
  19   return (Abs(aDist[0]) > aHSize[0] ||
  20           Abs(aDist[1]) > aHSize[1] ||
  21           Abs(aDist[2]) > aHSize[2]);
  22 }
  23
  24 inline Standard_Boolean _compareDistD (const gp_XYZ& aHSize,const gp_XYZ& aDist)
  25 {
  26   return (Abs(aDist.X()) > aHSize.X() ||
  27           Abs(aDist.Y()) > aHSize.Y() ||
  28           Abs(aDist.Z()) > aHSize.Z());
  29 }
  30
  31 //=======================================================================
  32 //function : Add
  33 //purpose  : Update the box by a point
  34 //=======================================================================
  35
  36 void Bnd_B3x::Add (const gp_XYZ& thePnt) {
  37   if (IsVoid()) {
  38     myCenter[0] = RealType(thePnt.X());
  39     myCenter[1] = RealType(thePnt.Y());
  40     myCenter[2] = RealType(thePnt.Z());
  41     myHSize [0] = 0.;
  42     myHSize [1] = 0.;
  43     myHSize [2] = 0.;
  44   } else {
  45     const RealType aDiff[3] = {
  46       RealType(thePnt.X()) - myCenter[0],
  47       RealType(thePnt.Y()) - myCenter[1],
  48       RealType(thePnt.Z()) - myCenter[2]
  49     };
  50     if (aDiff[0] > myHSize[0]) {
  51       const RealType aShift = (aDiff[0] - myHSize[0]) / 2;
  52       myCenter[0] += aShift;
  53       myHSize [0] += aShift;
  54     } else if (aDiff[0] < -myHSize[0]) {
  55       const RealType aShift = (aDiff[0] + myHSize[0]) / 2;
  56       myCenter[0] += aShift;
  57       myHSize [0] -= aShift;
  58     }
  59     if (aDiff[1] > myHSize[1]) {
  60       const RealType aShift = (aDiff[1] - myHSize[1]) / 2;
  61       myCenter[1] +=aShift;
  62       myHSize [1] +=aShift;
  63     } else if (aDiff[1] < -myHSize[1]) {
  64       const RealType aShift = (aDiff[1] + myHSize[1]) / 2;
  65       myCenter[1] += aShift;
  66       myHSize [1] -= aShift;
  67     }
  68     if (aDiff[2] > myHSize[2]) {
  69       const RealType aShift = (aDiff[2] - myHSize[2]) / 2;
  70       myCenter[2] +=aShift;
  71       myHSize [2] +=aShift;
  72     } else if (aDiff[2] < -myHSize[2]) {
  73       const RealType aShift = (aDiff[2] + myHSize[2]) / 2;
  74       myCenter[2] += aShift;
  75       myHSize [2] -= aShift;
  76     }
  77   }
  78 }
  79
  80 //=======================================================================
  81 //function : Limit
  82 //purpose  : limit the current box with the internals of theBox
  83 //=======================================================================
  84
  85 Standard_Boolean Bnd_B3x::Limit (const Bnd_B3x& theBox)
  86 {
  87   Standard_Boolean aResult (Standard_False);
  88   const RealType diffC[3] = {
  89     theBox.myCenter[0] - myCenter[0],
  90     theBox.myCenter[1] - myCenter[1],
  91     theBox.myCenter[2] - myCenter[2]
  92   };
  93   const RealType sumH[3] = {
  94     theBox.myHSize[0] + myHSize[0],
  95     theBox.myHSize[1] + myHSize[1],
  96     theBox.myHSize[2] + myHSize[2]
  97   };
  98   // check the condition IsOut
  99   if (_compareDist (sumH, diffC) == Standard_False) {
 100     const RealType diffH[3] = {
 101       theBox.myHSize[0] - myHSize[0],
 102       theBox.myHSize[1] - myHSize[1],
 103       theBox.myHSize[2] - myHSize[2]
 104     };
 105     if (diffC[0] - diffH[0] > 0.) {
 106       const RealType aShift = (diffC[0] - diffH[0]) / 2; // positive
 107       myCenter[0] += aShift;
 108       myHSize [0] -= aShift;
 109     } else if (diffC[0] + diffH[0] < 0.) {
 110       const RealType aShift = (diffC[0] + diffH[0]) / 2; // negative
 111       myCenter[0] += aShift;
 112       myHSize [0] += aShift;
 113     }
 114     if (diffC[1] - diffH[1] > 0.) {
 115       const RealType aShift = (diffC[1] - diffH[1]) / 2; // positive
 116       myCenter[1] += aShift;
 117       myHSize [1] -= aShift;
 118     } else if (diffC[1] + diffH[1] < 0.) {
 119       const RealType aShift = (diffC[1] + diffH[1]) / 2; // negative
 120       myCenter[1] += aShift;
 121       myHSize [1] += aShift;
 122     }
 123     if (diffC[2] - diffH[2] > 0.) {
 124       const RealType aShift = (diffC[2] - diffH[2]) / 2; // positive
 125       myCenter[2] += aShift;
 126       myHSize [2] -= aShift;
 127     } else if (diffC[2] + diffH[2] < 0.) {
 128       const RealType aShift = (diffC[2] + diffH[2]) / 2; // negative
 129       myCenter[2] += aShift;
 130       myHSize [2] += aShift;
 131     }
 132     aResult = Standard_True;
 133   }
 134   return aResult;
 135 }
 136
 137 //=======================================================================
 138 //function : Transformed
 139 //purpose  :
 140 //=======================================================================
 141
 142 Bnd_B3x Bnd_B3x::Transformed (const gp_Trsf& theTrsf) const
 143 {
 144   Bnd_B3x aResult;
 145   const gp_TrsfForm aForm = theTrsf.Form();
 146   const Standard_Real aScale = theTrsf.ScaleFactor();
 147   const Standard_Real aScaleAbs = Abs(aScale);
 148   if (aForm == gp_Identity)
 149     aResult = * this;
 150   else if (aForm== gp_Translation || aForm== gp_PntMirror || aForm== gp_Scale)
 151   {
 152     aResult.myCenter[0] =
 153       (RealType)(myCenter[0] * aScale + theTrsf.TranslationPart().X());
 154     aResult.myCenter[1] =
 155       (RealType)(myCenter[1] * aScale + theTrsf.TranslationPart().Y());
 156     aResult.myCenter[2] =
 157       (RealType)(myCenter[2] * aScale + theTrsf.TranslationPart().Z());
 158     aResult.myHSize[0] = (RealType)(myHSize[0] * aScaleAbs);
 159     aResult.myHSize[1] = (RealType)(myHSize[1] * aScaleAbs);
 160     aResult.myHSize[2] = (RealType)(myHSize[2] * aScaleAbs);
 161   } else {
 162     gp_XYZ aCenter ((Standard_Real)myCenter[0],
 163                     (Standard_Real)myCenter[1],
 164                     (Standard_Real)myCenter[2]);
 165     theTrsf.Transforms (aCenter);
 166     aResult.myCenter[0] = (RealType)aCenter.X();
 167     aResult.myCenter[1] = (RealType)aCenter.Y();
 168     aResult.myCenter[2] = (RealType)aCenter.Z();
 169
 170     const Standard_Real * aMat = &theTrsf.HVectorialPart().Value(1,1);
 171     aResult.myHSize[0] = (RealType)(aScaleAbs * (Abs(aMat[0]) * myHSize[0]+
 172                                                  Abs(aMat[1]) * myHSize[1]+
 173                                                  Abs(aMat[2]) * myHSize[2]));
 174     aResult.myHSize[1] = (RealType)(aScaleAbs * (Abs(aMat[3]) * myHSize[0]+
 175                                                  Abs(aMat[4]) * myHSize[1]+
 176                                                  Abs(aMat[5]) * myHSize[2]));
 177     aResult.myHSize[2] = (RealType)(aScaleAbs * (Abs(aMat[6]) * myHSize[0]+
 178                                                  Abs(aMat[7]) * myHSize[1]+
 179                                                  Abs(aMat[8]) * myHSize[2]));
 180   }
 181   return aResult;
 182 }
 183
 184 //=======================================================================
 185 //function : IsOut
 186 //purpose  : Intersection Box - Sphere
 187 //=======================================================================
 188
 189 Standard_Boolean Bnd_B3x::IsOut (const gp_XYZ&          theCenter,
 190                                  const Standard_Real    theRadius,
 191                                  const Standard_Boolean isSphereHollow) const
 192 {
 193   Standard_Boolean aResult (Standard_True);
 194   if (isSphereHollow == Standard_False) {
 195     // vector from the center of the sphere to the nearest box face
 196     const Standard_Real aDist[3] = {
 197       Abs(theCenter.X()-Standard_Real(myCenter[0])) - Standard_Real(myHSize[0]),
 198       Abs(theCenter.Y()-Standard_Real(myCenter[1])) - Standard_Real(myHSize[1]),
 199       Abs(theCenter.Z()-Standard_Real(myCenter[2])) - Standard_Real(myHSize[2])
 200     };
 201     Standard_Real aD (0.);
 202     if (aDist[0] > 0.)
 203       aD  = aDist[0]*aDist[0];
 204     if (aDist[1] > 0.)
 205       aD += aDist[1]*aDist[1];
 206     if (aDist[2] > 0.)
 207       aD += aDist[2]*aDist[2];
 208     aResult = (aD > theRadius*theRadius);
 209   } else {
 210     const Standard_Real aDistC[3] = {
 211       Abs(theCenter.X()-Standard_Real(myCenter[0])),
 212       Abs(theCenter.Y()-Standard_Real(myCenter[1])),
 213       Abs(theCenter.Z()-Standard_Real(myCenter[2]))
 214     };
 215     // vector from the center of the sphere to the nearest box face
 216     Standard_Real aDist[3] = {
 217       aDistC[0] - Standard_Real(myHSize[0]),
 218       aDistC[1] - Standard_Real(myHSize[1]),
 219       aDistC[2] - Standard_Real(myHSize[2])
 220     };
 221     Standard_Real aD (0.);
 222     if (aDist[0] > 0.)
 223       aD  = aDist[0]*aDist[0];
 224     if (aDist[1] > 0.)
 225       aD += aDist[1]*aDist[1];
 226     if (aDist[2] > 0.)
 227       aD += aDist[2]*aDist[2];
 228     if (aD < theRadius*theRadius) {
 229       // the box intersects the solid sphere; check if it is completely
 230       // inside the circle (in such case return isOut==True)
 231       aDist[0] = aDistC[0] + Standard_Real(myHSize[0]);
 232       aDist[1] = aDistC[1] + Standard_Real(myHSize[1]);
 233       aDist[2] = aDistC[2] + Standard_Real(myHSize[2]);
 234       if (aDist[0]*aDist[0]+aDist[1]*aDist[1]+aDist[2]*aDist[2]
 235            > theRadius*theRadius)
 236         aResult = Standard_False;
 237     }
 238   }
 239   return aResult;
 240 }
 241
 242 //=======================================================================
 243 //function : IsOut
 244 //purpose  : Intersection Box - transformed Box
 245 //=======================================================================
 246
 247 Standard_Boolean Bnd_B3x::IsOut (const Bnd_B3x& theBox,
 248                                  const gp_Trsf& theTrsf) const
 249 {
 250   Standard_Boolean aResult (Standard_False);
 251   const gp_TrsfForm aForm = theTrsf.Form();
 252   const Standard_Real aScale = theTrsf.ScaleFactor();
 253   const Standard_Real aScaleAbs = Abs(aScale);
 254   if (aForm == gp_Translation || aForm == gp_Identity ||
 255       aForm == gp_PntMirror   || aForm == gp_Scale)
 256   {
 257     aResult =
 258       (Abs (RealType(theBox.myCenter[0]*aScale + theTrsf.TranslationPart().X())
 259             - myCenter[0])
 260          > RealType (theBox.myHSize[0]*aScaleAbs) + myHSize[0] ||
 261        Abs (RealType(theBox.myCenter[1]*aScale + theTrsf.TranslationPart().Y())
 262             - myCenter[1])
 263          > RealType (theBox.myHSize[1]*aScaleAbs) + myHSize[1] ||
 264        Abs (RealType(theBox.myCenter[2]*aScale + theTrsf.TranslationPart().Y())
 265             - myCenter[2])
 266          > RealType (theBox.myHSize[2]*aScaleAbs) + myHSize[2]);
 267
 268   }
 269   else {
 270     // theBox is transformed and we check the resulting (enlarged) box against
 271     // 'this' box.
 272     const Standard_Real * aMat = &theTrsf.HVectorialPart().Value(1,1);
 273
 274     gp_XYZ aCenter ((Standard_Real)theBox.myCenter[0],
 275                     (Standard_Real)theBox.myCenter[1],
 276                     (Standard_Real)theBox.myCenter[2]);
 277     theTrsf.Transforms (aCenter);
 278     const Standard_Real aDist[3] = {
 279       aCenter.X() - (Standard_Real)myCenter[0],
 280       aCenter.Y() - (Standard_Real)myCenter[1],
 281       aCenter.Z() - (Standard_Real)myCenter[2]
 282     };
 283     const Standard_Real aMatAbs[9] = {
 284       Abs(aMat[0]), Abs(aMat[1]), Abs(aMat[2]), Abs(aMat[3]), Abs(aMat[4]),
 285       Abs(aMat[5]), Abs(aMat[6]), Abs(aMat[7]), Abs(aMat[8])
 286     };
 287     if (Abs(aDist[0]) > (aScaleAbs*(aMatAbs[0]*theBox.myHSize[0]+
 288                                     aMatAbs[1]*theBox.myHSize[1]+
 289                                     aMatAbs[2]*theBox.myHSize[2]) +
 290                          (Standard_Real)myHSize[0])    ||
 291         Abs(aDist[1]) > (aScaleAbs*(aMatAbs[3]*theBox.myHSize[0]+
 292                                     aMatAbs[4]*theBox.myHSize[1]+
 293                                     aMatAbs[5]*theBox.myHSize[2]) +
 294                          (Standard_Real)myHSize[1])    ||
 295         Abs(aDist[2]) > (aScaleAbs*(aMatAbs[6]*theBox.myHSize[0]+
 296                                     aMatAbs[7]*theBox.myHSize[1]+
 297                                     aMatAbs[8]*theBox.myHSize[2]) +
 298                          (Standard_Real)myHSize[2]))
 299       aResult = Standard_True;
 300
 301     else {
 302     // theBox is rotated, scaled and translated. We apply the reverse
 303     // translation and scaling then check against the rotated box 'this'
 304     if ((Abs(aMat[0]*aDist[0]+aMat[3]*aDist[1]+aMat[6]*aDist[2])
 305          > theBox.myHSize[0]*aScaleAbs + (aMatAbs[0]*myHSize[0] +
 306                                           aMatAbs[3]*myHSize[1] +
 307                                           aMatAbs[6]*myHSize[2])) ||
 308         (Abs(aMat[1]*aDist[0]+aMat[4]*aDist[1]+aMat[7]*aDist[2])
 309          > theBox.myHSize[1]*aScaleAbs + (aMatAbs[1]*myHSize[0] +
 310                                           aMatAbs[4]*myHSize[1] +
 311                                           aMatAbs[7]*myHSize[2])) ||
 312         (Abs(aMat[2]*aDist[0]+aMat[5]*aDist[1]+aMat[8]*aDist[2])
 313          > theBox.myHSize[2]*aScaleAbs + (aMatAbs[2]*myHSize[0] +
 314                                           aMatAbs[5]*myHSize[1] +
 315                                           aMatAbs[8]*myHSize[2])))
 316         aResult = Standard_True;
 317     }
 318   }
 319   return aResult;
 320 }
 321
 322 //=======================================================================
 323 //function : IsOut
 324 //purpose  :
 325 //=======================================================================
 326
 327 Standard_Boolean Bnd_B3x::IsOut (const gp_Ax3& thePlane) const
 328 {
 329   if (IsVoid())
 330     return Standard_True;
 331   const gp_XYZ& anOrigin = thePlane.Location().XYZ();
 332   const gp_XYZ& aDir     = thePlane.Direction().XYZ();
 333   const gp_XYZ  aBoxCenter ((Standard_Real)myCenter[0],
 334                             (Standard_Real)myCenter[1],
 335                             (Standard_Real)myCenter[2]);
 336   const Standard_Real aDist0 = (aBoxCenter - anOrigin) * aDir;
 337   // Find the signed distances from two opposite corners of the box to the plane
 338   // If the distances are not the same sign, then the plane crosses the box
 339   const Standard_Real aDist1 =   // proj of HSize on aDir
 340     Standard_Real(myHSize[0]) * Abs(aDir.X()) +
 341     Standard_Real(myHSize[1]) * Abs(aDir.Y()) +
 342     Standard_Real(myHSize[2]) * Abs(aDir.Z());
 343   return ((aDist0 + aDist1) * (aDist0 - aDist1) > 0.);
 344 }
 345
 346 //=======================================================================
 347 //function : IsOut
 348 //purpose  :
 349 //=======================================================================
 350
 351 Standard_Boolean Bnd_B3x::IsOut (const gp_Ax1&          theLine,
 352                                  const Standard_Boolean isRay,
 353                                  const Standard_Real    theOverthickness) const
 354 {
 355   const Standard_Real aRes = gp::Resolution() * 100.;
 356   if (IsVoid())
 357     return Standard_True;
 358   Standard_Real
 359     anInter0[2] = {-RealLast(), RealLast()},
 360     anInter1[2] = {-RealLast(), RealLast()};
 361   const gp_XYZ& aDir = theLine.Direction().XYZ();
 362   const gp_XYZ  aDiff ((Standard_Real)myCenter[0] - theLine.Location().X(),
 363                        (Standard_Real)myCenter[1] - theLine.Location().Y(),
 364                        (Standard_Real)myCenter[2] - theLine.Location().Z());
 365
 366   // Find the parameter interval in X dimention
 367   Standard_Real aHSize = (Standard_Real)myHSize[0]+theOverthickness;
 368   if (aDir.X() > aRes) {
 369     anInter0[0]= (aDiff.X() - aHSize) / aDir.X();
 370     anInter0[1]= (aDiff.X() + aHSize) / aDir.X();
 371   } else if (aDir.X() < -aRes) {
 372     anInter0[0]= (aDiff.X() + aHSize) / aDir.X();
 373     anInter0[1]= (aDiff.X() - aHSize) / aDir.X();
 374   } else
 375     // the line is orthogonal to OX axis. Test for inclusion in box limits
 376     if (Abs(aDiff.X()) > aHSize)
 377       return Standard_True;
 378
 379   // Find the parameter interval in Y dimention
 380   aHSize = (Standard_Real)myHSize[1]+theOverthickness;
 381   if (aDir.Y() > aRes) {
 382     anInter1[0]= (aDiff.Y() - aHSize) / aDir.Y();
 383     anInter1[1]= (aDiff.Y() + aHSize) / aDir.Y();
 384   } else if (aDir.Y() < -aRes) {
 385     anInter1[0]= (aDiff.Y() + aHSize) / aDir.Y();
 386     anInter1[1]= (aDiff.Y() - aHSize) / aDir.Y();
 387   } else
 388     // the line is orthogonal to OY axis. Test for inclusion in box limits
 389     if (Abs(aDiff.Y()) > aHSize)
 390       return Standard_True;
 391
 392   // Intersect Y-interval with X-interval
 393   if (anInter0[0] > (anInter1[1] + aRes) || anInter0[1] < (anInter1[0] - aRes))
 394     return Standard_True;
 395   if (anInter1[0] > anInter0[0])
 396     anInter0[0] = anInter1[0];
 397   if (anInter1[1] < anInter0[1])
 398     anInter0[1] = anInter1[1];
 399   if (isRay && anInter0[1] < -aRes)
 400     return Standard_True;
 401
 402   // Find the parameter interval in Z dimention
 403   aHSize = (Standard_Real)myHSize[2]+theOverthickness;
 404   if (aDir.Z() > aRes) {
 405     anInter1[0]= (aDiff.Z() - aHSize) / aDir.Z();
 406     anInter1[1]= (aDiff.Z() + aHSize) / aDir.Z();
 407   } else if (aDir.Z() < -aRes) {
 408     anInter1[0]= (aDiff.Z() + aHSize) / aDir.Z();
 409     anInter1[1]= (aDiff.Z() - aHSize) / aDir.Z();
 410   } else
 411     // the line is orthogonal to OZ axis. Test for inclusion in box limits
 412     return (Abs(aDiff.Z()) > aHSize);
 413   if (isRay && anInter1[1] < -aRes)
 414     return Standard_True;
 415
 416   return (anInter0[0] > (anInter1[1]+aRes) || anInter0[1] < (anInter1[0]-aRes));
 417 }
 418
 419 //=======================================================================
 420 //function : IsIn
 421 //purpose  : Test the complete inclusion of this box in transformed theOtherBox
 422 //=======================================================================
 423
 424 Standard_Boolean Bnd_B3x::IsIn (const Bnd_B3x& theBox,
 425                                 const gp_Trsf& theTrsf) const
 426 {
 427   Standard_Boolean aResult (Standard_False);
 428   const gp_TrsfForm aForm = theTrsf.Form();
 429   const Standard_Real aScale = theTrsf.ScaleFactor();
 430   const Standard_Real aScaleAbs = Abs(aScale);
 431   if (aForm == gp_Translation || aForm == gp_Identity ||
 432       aForm == gp_PntMirror   || aForm == gp_Scale)
 433   {
 434     aResult =
 435       (Abs (RealType(theBox.myCenter[0]*aScale + theTrsf.TranslationPart().X())
 436             - myCenter[0])
 437          < RealType (theBox.myHSize[0]*aScaleAbs) - myHSize[0] &&
 438        Abs (RealType(theBox.myCenter[1]*aScale + theTrsf.TranslationPart().Y())
 439             - myCenter[1])
 440          < RealType (theBox.myHSize[1]*aScaleAbs) - myHSize[1] &&
 441        Abs (RealType(theBox.myCenter[2]*aScale + theTrsf.TranslationPart().Y())
 442             - myCenter[2])
 443          < RealType (theBox.myHSize[2]*aScaleAbs) - myHSize[2]);
 444
 445   } else {
 446     // theBox is rotated, scaled and translated. We apply the reverse
 447     // translation and scaling then check against the rotated box 'this'
 448     const Standard_Real * aMat = &theTrsf.HVectorialPart().Value(1,1);
 449     gp_XYZ aCenter ((Standard_Real)theBox.myCenter[0],
 450                     (Standard_Real)theBox.myCenter[1],
 451                     (Standard_Real)theBox.myCenter[2]);
 452     theTrsf.Transforms (aCenter);
 453     const Standard_Real aDist[3] = {
 454       aCenter.X() - (Standard_Real)myCenter[0],
 455       aCenter.Y() - (Standard_Real)myCenter[1],
 456       aCenter.Z() - (Standard_Real)myCenter[2]
 457     };
 458     if ((Abs(aMat[0]*aDist[0]+aMat[3]*aDist[1]+aMat[6]*aDist[2])
 459          < theBox.myHSize[0]*aScaleAbs - (Abs(aMat[0])*myHSize[0] +
 460                                           Abs(aMat[3])*myHSize[1] +
 461                                           Abs(aMat[6])*myHSize[2])) &&
 462         (Abs(aMat[1]*aDist[0]+aMat[4]*aDist[1]+aMat[7]*aDist[2])
 463          < theBox.myHSize[1]*aScaleAbs - (Abs(aMat[1])*myHSize[0] +
 464                                           Abs(aMat[4])*myHSize[1] +
 465                                           Abs(aMat[7])*myHSize[2])) &&
 466         (Abs(aMat[2]*aDist[0]+aMat[5]*aDist[1]+aMat[8]*aDist[2])
 467          < theBox.myHSize[2]*aScaleAbs - (Abs(aMat[2])*myHSize[0] +
 468                                           Abs(aMat[5])*myHSize[1] +
 469                                           Abs(aMat[8])*myHSize[2])))
 470       aResult = Standard_True;
 471   }
 472   return aResult;
 473 }
 474