geometry_example.cc

#include <Geometry/Vector.h>
#include <Geometry/Sphere.h>
#include <Geometry/Point.h>
#include <Geometry/CoordinateSystem.h>
#include <Units/PhysicalUnits.h>

#include <iostream>
#include <typeinfo>
#include <cstdlib>

using namespace phys::units; 
using namespace phys::units::io; // support stream << unit
using namespace phys::units::literals; // support unit literals like 5_m;

int main()
{
    //~ // define the root coordinate system
    CoordinateSystem root;
    
    // another CS defined by a translation relative to the root CS
    CoordinateSystem cs2 = root.translate({0_m, 0_m, 1_m});
    
    // rotations are possible, too; parameters are axis vector and angle
    CoordinateSystem cs3 = root.rotate({1_m, 0_m, 0_m}, 90 * degree_angle);
    
    // now let's define some geometrical objects:
    Point const p1(root, {0_m, 0_m, 0_m}); // the origin of the root CS
    Point const p2(cs2, {0_m, 0_m, 0_m}); // the origin of cs2
    
    Vector<length_d> const diff = p2 - p1; // the distance between the points, basically the translation vector given above
    auto const norm = diff.squaredNorm(); // squared length with the right dimension
    
    // print the components of the vector as given in the different CS
    std::cout << "p2-p1 components in root: " << diff.getComponents(root) << std::endl;
    std::cout << "p2-p1 components in cs2: " << diff.getComponents(cs2) << std::endl; // by definition invariant under translations
    std::cout << "p2-p1 components in cs3: " << diff.getComponents(cs3) << std::endl; // but not under rotations
    std::cout << "p2-p1 norm^2: " << norm << std::endl;
    
    Sphere s(p1, 10_m); // define a sphere around a point with a radius
    //~ std::cout << "p1 inside s:  " << s.isInside(p2) << std::endl;    
    
    Sphere s2(p1, 3_um); // another sphere
    //~ std::cout << "p1 inside s2: " << s2.isInside(p2) << std::endl;
    
    
    // let's try parallel projections:
    auto const v1 = Vector<length_d>(root, {1_m, 1_m, 0_m});
    auto const v2 = Vector<length_d>(root, {1_m, 0_m, 0_m});

    auto const v3 = v1.parallelProjectionOnto(v2);
    
    auto const cross = v1.cross(v2).normalized();
    
    // if a CS is not given as parameter for getComponents(), the components
    // in the "home" CS are returned
    std::cout << v1.getComponents() << std::endl;
    std::cout << v2.getComponents() << std::endl;
    std::cout << v3.getComponents() << std::endl;
    std::cout << cross.getComponents() << std::endl;
    
    return EXIT_SUCCESS;
}