geom.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Capgemini Engineering Research and Development.
//
// This file is part of OCCT-Light software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Affero General Public License version 3 as published
// by the Free Software Foundation, with an option to use any later version.
// Consult the file LICENSE_AGPL_30.txt included in OCCT-Light distribution
// for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of a commercial
// license or contractual agreement.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef OCCTL_HPP_GEOM_HPP
#define OCCTL_HPP_GEOM_HPP
 
#include <occtl/occtl_geom.h>
 
#include <occtl-hpp/core.hpp>
 
#include <cmath>
 
namespace occtl
{
 
struct Point2
{
  Point2() noexcept
      : myData{0.0, 0.0}
  {
  }
 
  Point2(const double theX, const double theY) noexcept
      : myData{theX, theY}
  {
  }
 
  explicit Point2(const occtl_point2_t& theC) noexcept
      : myData(theC)
  {
  }
 
  const occtl_point2_t& c_type() const noexcept { return myData; }
 
  double x() const noexcept { return myData.x; } 
 
  double y() const noexcept { return myData.y; } 
 
  double distance_to(const Point2& theOther) const noexcept
  {
    return ::occtl_point2_distance(myData, theOther.myData);
  }
 
  Point2 midpoint(const Point2& theOther) const noexcept
  {
    return Point2(::occtl_point2_midpoint(myData, theOther.myData));
  }
 
private:
  occtl_point2_t myData;
};
 
struct Point3
{
  Point3() noexcept
      : myData{0.0, 0.0, 0.0}
  {
  }
 
  Point3(const double theX, const double theY, const double theZ) noexcept
      : myData{theX, theY, theZ}
  {
  }
 
  explicit Point3(const occtl_point3_t& theC) noexcept
      : myData(theC)
  {
  }
 
  const occtl_point3_t& c_type() const noexcept { return myData; }
 
  double x() const noexcept { return myData.x; } 
 
  double y() const noexcept { return myData.y; } 
 
  double z() const noexcept { return myData.z; } 
 
  double distance_to(const Point3& theOther) const noexcept
  {
    return ::occtl_point3_distance(myData, theOther.myData);
  }
 
  Point3 midpoint(const Point3& theOther) const noexcept
  {
    return Point3(::occtl_point3_midpoint(myData, theOther.myData));
  }
 
private:
  occtl_point3_t myData;
};
 
struct Vector2
{
  Vector2() noexcept
      : myData{0.0, 0.0}
  {
  }
 
  Vector2(const double theX, const double theY) noexcept
      : myData{theX, theY}
  {
  }
 
  explicit Vector2(const occtl_vector2_t& theC) noexcept
      : myData(theC)
  {
  }
 
  const occtl_vector2_t& c_type() const noexcept { return myData; }
 
  double x() const noexcept { return myData.x; } 
 
  double y() const noexcept { return myData.y; } 
 
  double dot(const Vector2& theOther) const noexcept
  {
    return ::occtl_vector2_dot(myData, theOther.myData);
  }
 
  double cross(const Vector2& theOther) const noexcept
  {
    return ::occtl_vector2_cross(myData, theOther.myData);
  }
 
  double magnitude() const noexcept { return ::occtl_vector2_magnitude(myData); }
 
  Vector2 normalized() const
  {
    occtl_vector2_t aResult{};
    check(::occtl_vector2_normalized(myData, &aResult));
    return Vector2(aResult);
  }
 
private:
  occtl_vector2_t myData;
};
 
struct Vector3
{
  Vector3() noexcept
      : myData{0.0, 0.0, 0.0}
  {
  }
 
  Vector3(const double theX, const double theY, const double theZ) noexcept
      : myData{theX, theY, theZ}
  {
  }
 
  explicit Vector3(const occtl_vector3_t& theC) noexcept
      : myData(theC)
  {
  }
 
  const occtl_vector3_t& c_type() const noexcept { return myData; }
 
  double x() const noexcept { return myData.x; } 
 
  double y() const noexcept { return myData.y; } 
 
  double z() const noexcept { return myData.z; } 
 
  double dot(const Vector3& theOther) const noexcept
  {
    return ::occtl_vector3_dot(myData, theOther.myData);
  }
 
  Vector3 cross(const Vector3& theOther) const noexcept
  {
    return Vector3(::occtl_vector3_cross(myData, theOther.myData));
  }
 
  double magnitude() const noexcept { return ::occtl_vector3_magnitude(myData); }
 
  Vector3 normalized() const
  {
    occtl_vector3_t aResult{};
    check(::occtl_vector3_normalized(myData, &aResult));
    return Vector3(aResult);
  }
 
  Vector3 operator+(const Vector3& theOther) const noexcept
  {
    return Vector3(::occtl_vector3_add(myData, theOther.myData));
  }
 
  Vector3 operator-(const Vector3& theOther) const noexcept
  {
    return Vector3(::occtl_vector3_sub(myData, theOther.myData));
  }
 
  Vector3 operator*(const double theS) const noexcept
  {
    return Vector3(::occtl_vector3_scaled(myData, theS));
  }
 
  Vector3 reversed() const noexcept { return Vector3(::occtl_vector3_reversed(myData)); }
 
  double angle(const Vector3& theOther) const
  {
    double aRad = 0.0;
    check(::occtl_vector3_angle(myData, theOther.myData, &aRad));
    return aRad;
  }
 
private:
  occtl_vector3_t myData;
};
 
struct Direction2
{
  explicit Direction2(const occtl_direction2_t& theC) noexcept
      : myData(theC)
  {
  }
 
  static Direction2 from_vector(const Vector2& theV)
  {
    occtl_direction2_t aResult{};
    check(::occtl_direction2_from_vector(theV.c_type(), &aResult));
    return Direction2(aResult);
  }
 
  const occtl_direction2_t& c_type() const noexcept { return myData; }
 
  double x() const noexcept { return myData.x; } 
 
  double y() const noexcept { return myData.y; } 
 
  double angle(const Direction2& theOther) const noexcept
  {
    return ::occtl_direction2_angle(myData, theOther.myData);
  }
 
private:
  occtl_direction2_t myData;
};
 
struct Direction3
{
  explicit Direction3(const occtl_direction3_t& theC) noexcept
      : myData(theC)
  {
  }
 
  static Direction3 from_vector(const Vector3& theV)
  {
    occtl_direction3_t aResult{};
    check(::occtl_direction3_from_vector(theV.c_type(), &aResult));
    return Direction3(aResult);
  }
 
  const occtl_direction3_t& c_type() const noexcept { return myData; }
 
  double x() const noexcept { return myData.x; } 
 
  double y() const noexcept { return myData.y; } 
 
  double z() const noexcept { return myData.z; } 
 
  double dot(const Direction3& theOther) const noexcept
  {
    return ::occtl_direction3_dot(myData, theOther.myData);
  }
 
  Vector3 cross(const Direction3& theOther) const noexcept
  {
    return Vector3(::occtl_direction3_cross(myData, theOther.myData));
  }
 
  double angle(const Direction3& theOther) const noexcept
  {
    return ::occtl_direction3_angle(myData, theOther.myData);
  }
 
  Direction3 reversed() const noexcept { return Direction3(::occtl_direction3_reversed(myData)); }
 
private:
  occtl_direction3_t myData;
};
 
struct Axis1Placement
{
  explicit Axis1Placement(const occtl_axis1_placement_t& theC) noexcept
      : myData(theC)
  {
  }
 
  Axis1Placement(const Point3& theLocation, const Direction3& theDir) noexcept
      : myData{theLocation.c_type(), theDir.c_type()}
  {
  }
 
  const occtl_axis1_placement_t& c_type() const noexcept { return myData; }
 
private:
  occtl_axis1_placement_t myData;
};
 
struct Axis2Placement
{
  explicit Axis2Placement(const occtl_axis2_placement_t& theC) noexcept
      : myData(theC)
  {
  }
 
  Axis2Placement(const Point3&     theLocation,
                 const Direction3& theXDir,
                 const Direction3& theXDirRef) noexcept
      : myData{theLocation.c_type(), theXDir.c_type(), theXDirRef.c_type()}
  {
  }
 
  const occtl_axis2_placement_t& c_type() const noexcept { return myData; }
 
private:
  occtl_axis2_placement_t myData;
};
 
struct Axis3Placement
{
  explicit Axis3Placement(const occtl_axis3_placement_t& theC) noexcept
      : myData(theC)
  {
  }
 
  Axis3Placement(const Point3&     theLocation,
                 const Direction3& theXDir,
                 const Direction3& theYDir,
                 const Direction3& theZDir) noexcept
      : myData{theLocation.c_type(), theXDir.c_type(), theYDir.c_type(), theZDir.c_type()}
  {
  }
 
  const occtl_axis3_placement_t& c_type() const noexcept { return myData; }
 
private:
  occtl_axis3_placement_t myData;
};
 
struct Transform
{
  explicit Transform(const occtl_transform_t& theC) noexcept
      : myData(theC)
  {
  }
 
  static Transform identity() noexcept { return Transform(::occtl_transform_identity()); }
 
  static Transform translation(const Vector3& theV) noexcept
  {
    return Transform(::occtl_transform_translation(theV.c_type()));
  }
 
  static Transform rotation(const Axis1Placement& theAxis, const double theAngle)
  {
    occtl_transform_t aResult{};
    check(::occtl_transform_rotation(theAxis.c_type(), theAngle, &aResult));
    return Transform(aResult);
  }
 
  static Transform scale(const Point3& theCenter, const double theFactor)
  {
    occtl_transform_t aResult{};
    check(::occtl_transform_scale(theCenter.c_type(), theFactor, &aResult));
    return Transform(aResult);
  }
 
  static Transform from_axis2(const Axis2Placement& theFrame)
  {
    occtl_transform_t aResult{};
    check(::occtl_transform_from_axis2(theFrame.c_type(), &aResult));
    return Transform(aResult);
  }
 
  static Transform from_axis3(const Axis3Placement& theFrame)
  {
    occtl_transform_t aResult{};
    check(::occtl_transform_from_axis3(theFrame.c_type(), &aResult));
    return Transform(aResult);
  }
 
  const occtl_transform_t& c_type() const noexcept { return myData; }
 
  Point3 apply(const Point3& theP) const noexcept
  {
    return Point3(::occtl_transform_apply_point3(myData, theP.c_type()));
  }
 
  Vector3 apply(const Vector3& theV) const noexcept
  {
    return Vector3(::occtl_transform_apply_vector3(myData, theV.c_type()));
  }
 
  Direction3 apply(const Direction3& theD) const
  {
    occtl_direction3_t aResult{};
    check(::occtl_direction3_transform(theD.c_type(), myData, &aResult));
    return Direction3(aResult);
  }
 
  Transform compose(const Transform& theSecond) const noexcept
  {
    return Transform(::occtl_transform_compose(myData, theSecond.myData));
  }
 
  Transform inverted() const
  {
    occtl_transform_t aResult{};
    check(::occtl_transform_inverted(myData, &aResult));
    return Transform(aResult);
  }
 
private:
  occtl_transform_t myData;
};
 
} // namespace occtl
 
#endif // OCCTL_HPP_GEOM_HPP