---
name: "SbSphereSheetProjector"
section: "3"
platform: "linux"
package: "coin"
version: "1:4.0.10-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/SbSphereSheetProjector"
---

# SbSphereSheetProjector(3)

The SbSphereSheetProjector class projects 2D points to 3D points on a sheet covering a spherical shape.

## NAME

SbSphereSheetProjector - The **SbSphereSheetProjector** class projects 2D points to 3D points on a sheet covering a spherical shape.

## SYNOPSIS

\#include \<Inventor/projectors/SbSphereSheetProjector.h\>

Inherits **SbSphereProjector**.

### Public Member Functions

**SbSphereSheetProjector** (const SbBool orienttoeye=TRUE)\
 **SbSphereSheetProjector** (const **SbSphere** &sph, const SbBool orienttoeye=TRUE)\
 virtual **SbProjector** \* **copy** (void) const\
 virtual **SbVec3f** **project** (const **SbVec2f** &point)\
 virtual **SbRotation** **getRotation** (const **SbVec3f** &point1, const **SbVec3f** &point2)\

Public Member Functions inherited from **SbSphereProjector** **SbVec3f** **projectAndGetRotation** (const **SbVec2f** &point, **SbRotation** &rot)\
 void **setSphere** (const **SbSphere** &sph)\
 const **SbSphere** & **getSphere** (void) const\
 void **setOrientToEye** (const SbBool orienttoeye)\
 SbBool **isOrientToEye** (void) const\
 void **setFront** (const SbBool infront)\
 SbBool **isFront** (void) const\
 SbBool **isPointInFront** (const **SbVec3f** &point) const\
 virtual void **setWorkingSpace** (const **SbMatrix** &space)\

Public Member Functions inherited from **SbProjector** virtual void **setViewVolume** (const **SbViewVolume** &vol)\
 const **SbViewVolume** & **getViewVolume** (void) const\
 const **SbMatrix** & **getWorkingSpace** (void) const\
 virtual SbBool **tryProject** (const **SbVec2f** &point, const float epsilon, **SbVec3f** &result)\

### Protected Member Functions

void **setupPlane** (void)\

Protected Member Functions inherited from **SbSphereProjector** **SbSphereProjector** (const SbBool orienttoeye)\
 **SbSphereProjector** (const **SbSphere** &s, const SbBool orienttoeye)\
 SbBool **intersectSphereFront** (const **SbLine** &l, **SbVec3f** &result)\

Protected Member Functions inherited from **SbProjector** **SbProjector** (void)\
 virtual **~SbProjector** ()\
 **SbLine** **getWorkingLine** (const **SbVec2f** &point) const\
 float **findVanishingDistance** (void) const\
 SbBool **verifyProjection** (const **SbVec3f** &projpt) const\

### Protected Attributes

**SbVec3f** **workingProjPoint**\
 **SbVec3f** **planePoint**\
 **SbVec3f** **planeDir**\
 float **planeDist**\
 **SbPlane** **tolPlane**\

Protected Attributes inherited from **SbSphereProjector** SbBool **intersectFront**\
 **SbSphere** **sphere**\
 SbBool **orientToEye**\
 SbBool **needSetup**\
 **SbVec3f** **lastPoint**\

Protected Attributes inherited from **SbProjector** **SbViewVolume** **viewVol**\
 **SbMatrix** **worldToWorking**\
 **SbMatrix** **workingToWorld**\

## Detailed Description

The **SbSphereSheetProjector** class projects 2D points to 3D points on a sheet covering a spherical shape.

The following standalone example shows how screen space coordinates projects into 3D when mapped with an **SbSphereSheetProjector**. It outputs the resulting projections as an **SoPointSet** in a Inventor-file on stdout:

```
#include <cstdio>
#include <Inventor/SbLinear.h>
#include <Inventor/projectors/SbSphereSheetProjector.h>
#include <Inventor/SoDB.h>
int
main(void)
{
  SoDB::init();
  const float START = 0.0f;
  const float END = 1.0f;
  const float STEPS = 50.0f;
  const float STEPSIZE = ((END - START) / STEPS);
  SbSphere s(SbVec3f(0, 0, 0), 0.8);
  SbSphereSheetProjector ssp(s, TRUE); // last argument is orientToEye
  SbViewVolume volume;
  volume.ortho(-1, 1, -1, 1, -1, 1);
  ssp.setViewVolume(volume);
  (void)fprintf(stdout, "#Inventor V2.1 ascii\n\n"
                "Separator {\n"
                "  Coordinate3 {\n"
                "    point [\n");
  for (float i=START; i <= END; i += STEPSIZE) {
    for (float j=START; j <= END; j += STEPSIZE) {
      SbVec3f v = ssp.project(SbVec2f(j, i));
      (void)fprintf(stdout, "\t%f %f %f,\n", v[0], v[1], v[2]);
    }
  }
  (void)fprintf(stdout, "      ]\n"
                "    }\n"
                "  DrawStyle { pointSize 2 }\n"
                "  PointSet { }\n"
                "}\n");
  return 0;
}
```

The projections to 3D points in the resulting Inventor-file looks like this:

## Constructor & Destructor Documentation

### SbSphereSheetProjector::SbSphereSheetProjector (const SbBool orienttoeye = TRUE)

Constructor. Uses default sphere definition, see **SbSphereProjector::SbSphereProjector()**.

*orienttoeye* decides whether or not the sheet should always be oriented towards the viewer.

### SbSphereSheetProjector::SbSphereSheetProjector (const SbSphere & sph, const SbBool orienttoeye = TRUE)

Constructor with explicit definition of projection sphere.

## Member Function Documentation

### SbProjector \* SbSphereSheetProjector::copy (void ) const \[virtual\]

Construct and return a copy of this projector. The caller is responsible for destructing the new instance.

**Note that if the Coin library has been built as a DLL under Microsoft Windows and you use this method from application code, you** *must* **make sure that both the Coin DLL and the application executable are using the same instance of a C Run-Time (CRT) library. Otherwise, you** *will* **get memory heap corruption upon deallocating the returned instances, eventually leading to mysterious crashes.**\

*Implements* **SbProjector***.*

### SbVec3f SbSphereSheetProjector::project (const SbVec2f & point) \[virtual\]

*Project the 2D point from normalized viewport coordinates to a 3D point. The mapping will be done in accordance with the type of the projector.*

*Implements* **SbProjector***.*

### SbRotation SbSphereSheetProjector::getRotation (const SbVec3f & point1, const SbVec3f & point2) \[virtual\]

*Returns rotation on the projection surface which reorients point1 to point2.*

*Implements* **SbSphereProjector***.*

### void SbSphereSheetProjector::setupPlane (void ) \[protected\]

*Recalculates projection surface settings after changes to the parameters.*

## Member Data Documentation

### SbVec3f SbSphereSheetProjector::workingProjPoint \[protected\]

*Last projected point, in the working space coordinate system.*

### SbVec3f SbSphereSheetProjector::planePoint \[protected\]

*Position of the center of the sphere in the plane of the hyberbolic sheet.*

### SbVec3f SbSphereSheetProjector::planeDir \[protected\]

*Normal vector of the plane defining the orientation of the sheet.*

### float SbSphereSheetProjector::planeDist \[protected\]

*This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.*\

### SbPlane SbSphereSheetProjector::tolPlane \[protected\]

*The tolerance value specifying how much of the sphere is "above" the sheet.*

## Author

*Generated automatically by Doxygen for Coin from the source code.*