// Copyright (c) 1995-1999 Matra Datavision // Copyright (c) 1999-2012 OPEN CASCADE SAS // // The content of this file is subject to the Open CASCADE Technology Public // License Version 6.5 (the "License"). You may not use the content of this file // except in compliance with the License. Please obtain a copy of the License // at http://www.opencascade.org and read it completely before using this file. // // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France. // // The Original Code and all software distributed under the License is // distributed on an "AS IS" basis, without warranty of any kind, and the // Initial Developer hereby disclaims all such warranties, including without // limitation, any warranties of merchantability, fitness for a particular // purpose or non-infringement. Please see the License for the specific terms // and conditions governing the rights and limitations under the License. inline gp_Sphere::gp_Sphere () : radius (RealLast()) { } inline gp_Sphere::gp_Sphere (const gp_Ax3& A3, const Standard_Real Radius) : pos (A3), radius (Radius) { Standard_ConstructionError_Raise_if (Radius < 0.0,""); } inline void gp_Sphere::SetLocation (const gp_Pnt& Loc) { pos.SetLocation (Loc); } inline void gp_Sphere::SetPosition (const gp_Ax3& A3) { pos = A3; } inline void gp_Sphere::SetRadius (const Standard_Real R) { Standard_ConstructionError_Raise_if (R < 0.0,""); radius = R; } inline Standard_Real gp_Sphere::Area () const { return 4.0 * M_PI * radius * radius; } inline void gp_Sphere::UReverse() { pos.YReverse(); } inline void gp_Sphere::VReverse() { pos.ZReverse(); } inline Standard_Boolean gp_Sphere::Direct() const { return pos.Direct(); } inline const gp_Pnt& gp_Sphere::Location () const { return pos.Location(); } inline const gp_Ax3& gp_Sphere::Position () const { return pos; } inline Standard_Real gp_Sphere::Radius () const { return radius; } inline Standard_Real gp_Sphere::Volume () const { return (4.0 * M_PI * radius * radius * radius) / 3.0; } inline gp_Ax1 gp_Sphere::XAxis () const { return gp_Ax1(pos.Location(), pos.XDirection()); } inline gp_Ax1 gp_Sphere::YAxis () const { return gp_Ax1(pos.Location(), pos.YDirection()); } inline void gp_Sphere::Rotate (const gp_Ax1& A1, const Standard_Real Ang) { pos.Rotate (A1, Ang); } inline gp_Sphere gp_Sphere::Rotated (const gp_Ax1& A1, const Standard_Real Ang) const { gp_Sphere C = *this; C.pos.Rotate (A1, Ang); return C; } inline void gp_Sphere::Scale (const gp_Pnt& P, const Standard_Real S) { pos.Scale (P, S); radius *= S; if (radius < 0) radius = - radius; } inline gp_Sphere gp_Sphere::Scaled (const gp_Pnt& P, const Standard_Real S) const { gp_Sphere C = *this; C.pos.Scale (P, S); C.radius *= S; if (C.radius < 0) C.radius = - C.radius; return C; } inline void gp_Sphere::Transform (const gp_Trsf& T) { pos.Transform (T); radius *= T.ScaleFactor(); if (radius < 0) radius = - radius; } inline gp_Sphere gp_Sphere::Transformed (const gp_Trsf& T) const { gp_Sphere C = *this; C.pos.Transform (T); C.radius *= T.ScaleFactor(); if (C.radius < 0) C.radius = - C.radius; return C; } inline void gp_Sphere::Translate (const gp_Vec& V) { pos.Translate (V); } inline gp_Sphere gp_Sphere::Translated (const gp_Vec& V) const { gp_Sphere C = *this; C.pos.Translate (V); return C; } inline void gp_Sphere::Translate (const gp_Pnt& P1, const gp_Pnt& P2) { pos.Translate (P1, P2); } inline gp_Sphere gp_Sphere::Translated (const gp_Pnt& P1, const gp_Pnt& P2) const { gp_Sphere C = *this; C.pos.Translate (P1, P2); return C; }