angelcad.h

Go to the documentation of this file.

class array {
public:
   array(int&in);

   array(int&in, uint length);

   array(int&in, uint length, const T&in value);

  T&  opIndex(uint index);

  T[]&  opAssign(const T[]&in);

  bool  empty() const;

  bool  isEmpty() const;

  bool  opEquals(const T[]&in) const;

  const  T& opIndex(uint index) const;

  int  find(const T&in value) const;

  int  find(uint startAt, const T&in value) const;

  int  findByRef(const T&in value) const;

  int  findByRef(uint startAt, const T&in value) const;

  uint  length() const;

  uint  size() const;

  void  erase(uint);

  void  insert(uint index, const T&in value);

  void  insert(uint index, const T[]&inout arr);

  void  insertAt(uint index, const T&in value);

  void  insertAt(uint index, const T[]&inout arr);

  void  insertLast(const T&in value);

  void  pop_back();

  void  push_back(const T&in);

  void  removeAt(uint index);

  void  removeLast();

  void  removeRange(uint start, uint count);

  void  reserve(uint length);

  void  resize(uint length);

  void  reverse();

  void  sort(array::less&in, uint startAt = 0, uint count = uint ( - 1 ));

  void  sortAsc();

  void  sortAsc(uint startAt, uint count);

  void  sortDesc();

  void  sortDesc(uint startAt, uint count);

};

class as_args {
public:
  bool  has_argument(string arg) const;

  double  get_double(string arg) const;

  double  get_double(string arg, double def) const;

  double  get_unsigned_double(string arg) const;

  double  get_unsigned_double(string arg, double def) const;

  int  get_int(string arg) const;

  int  get_int(string arg, int def) const;

  string  get_string(string arg) const;

  string  get_string(string arg, string def) const;

  uint  get_uint(string arg) const;

  uint  get_uint(string arg, uint def) const;

};


class as_istream {
public:
  as_istream&  opShr(bool&out v);

  as_istream&  opShr(double&out v);

  as_istream&  opShr(float&out v);

  as_istream&  opShr(int&out v);

  as_istream&  opShr(int64&out v);

  as_istream&  opShr(string&out v);

  as_istream&  opShr(uint&out v);

  as_istream&  opShr(uint64&out v);

};

class as_ostream {
public:
  as_ostream&  opShl(bool v);

  as_ostream&  opShl(const string&in v);

  as_ostream&  opShl(double v);

  as_ostream&  opShl(float v);

  as_ostream&  opShl(int64 v);

  as_ostream&  opShl(uint64 v);

};


class boundingbox {
public:
   boundingbox();


  bool  is_empty() const;


  double  diagonal() const;


  double  dx() const;


  double  dy() const;


  double  dz() const;


  pos3d@  center() const;


  pos3d@  p1() const;


  pos3d@  p2() const;


  void  enclose(pos3d@ p);

};


class circle : public shape2d {
public:

   circle(const pos2d@ p1, const pos2d@ p2, const pos2d@ p3);


   circle(double r);


  double  r() const;


  double  radius() const;

};


class cone : public solid {
public:

   cone(double h, double r1, double r2, bool center = false);


  double  h() const;


  double  height() const;


  double  r1() const;


  double  r2() const;


  double  radius1() const;


  double  radius2() const;

};

class cube : public solid {
public:
   cube(double size, bool center = false);

  double  size() const;

};


class cuboid : public solid {
public:

   cuboid(double dx, double dy, double dz, bool center = false);


  double  dx() const;


  double  dy() const;


  double  dz() const;

};


class cylinder : public solid {
public:

   cylinder(double h, double r, bool center = false);


  double  h() const;


  double  height() const;


  double  r() const;


  double  radius() const;

};


class difference2d : public shape2d {
public:

   difference2d(shape2d@ incl, shape2d@ excl);

};


class difference3d : public solid {
public:

   difference3d(solid@ incl, solid@ excl);

};


class fill2d : public shape2d {
public:

   fill2d(const shape2d@ s1);


   fill2d(array<shape2d@>@ arr);

};


class hmatrix : public tmatrix {
public:

   hmatrix(const vec3d@ xvec, const vec3d@ yvec, const pos3d@ pos = pos3d ( 0 , 0 , 0 ));


   hmatrix(const vec3d@ xvec, const vec3d@ yvec, const vec3d@ zvec, const pos3d@ pos = pos3d ( 0 , 0 , 0 ));

};


class hull2d : public shape2d {
public:

   hull2d(const shape2d@ s1, const shape2d@ s2);


   hull2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3);


   hull2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3, const shape2d@ s4);


   hull2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3, const shape2d@ s4, const shape2d@ s5);


   hull2d(array<shape2d@>@ arr);

};


class hull3d : public solid {
public:

   hull3d(const solid@ s1, const solid@ s2);


   hull3d(const solid@ s1, const solid@ s2, const solid@ s3);


   hull3d(const solid@ s1, const solid@ s2, const solid@ s3, const solid@ s4);


   hull3d(const solid@ s1, const solid@ s2, const solid@ s3, const solid@ s4, const solid@ s5);


   hull3d(array<solid@>@ arr);

};


class intersection2d : public shape2d {
public:

   intersection2d(const shape2d@ s1, const shape2d@ s2);


   intersection2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3);


   intersection2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3, const shape2d@ s4);


   intersection2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3, const shape2d@ s4, const shape2d@ s5);


   intersection2d(array<shape2d@>@ arr);

};


class intersection3d : public solid {
public:

   intersection3d(const solid@ s1, const solid@ s2);


   intersection3d(const solid@ s1, const solid@ s2, const solid@ s3);


   intersection3d(const solid@ s1, const solid@ s2, const solid@ s3, const solid@ s4);


   intersection3d(const solid@ s1, const solid@ s2, const solid@ s3, const solid@ s4, const solid@ s5);


   intersection3d(array<solid@>@ arr);

};

class line2d {
public:

   line2d(const pos2d@ p1, const pos2d@ p2);


  double  length() const;


  double  project(pos2d@ point) const;


  pos2d@  end1() const;


  pos2d@  end2() const;


  pos2d@  interpolate(double par) const;

};

class line3d {
public:

   line3d(const pos3d@ p1, const pos3d@ p2);


  double  length() const;


  double  project(pos3d@ point) const;


  pos3d@  end1() const;


  pos3d@  end2() const;


  pos3d@  interpolate(double par) const;

};


class linear_extrude : public solid {
public:

   linear_extrude(const shape2d@ shape, double height);


  double  height() const;

};


class locsys3d {
public:

   locsys3d(const vec3d@ xvec, const vec3d@ zvec);


  vec3d@  x() const;


  vec3d@  y() const;


  vec3d@  z() const;

};


class map {
public:
   map(int&in);

   map(int&in, map<T_key,T_value>@);

  T_value&  find(const T_key&in);

  T_value&  find(const T_key&in, bool&out);

  bool  contains(const T_key&in);

  bool  empty();

  bool  erase(const map_iterator<T_key,T_value>&in);

  const  T_value& get_opIndex(const T_key&in) const;

  int  erase(const map_iterator<T_key,T_value>&in, const map_iterator<T_key,T_value>&in);

  int  size();

  map<T_key,T_value>&  opAssign(map<T_key,T_value>@);

  map<T_key,T_value>&  swap(map<T_key,T_value>&inout);

  map_iterator<T_key,T_value>  begin();

  map_iterator<T_key,T_value>  end();

  map_iterator<T_key,T_value>  find_iterator(const T_key&in);

  void  SetDirectcomp(bool);

  void  clear();

  void  erase(const T_key&in);

  void  insert(const T_key&in, const T_value&in);

  void  set_opIndex(const T_key&in, const T_value&in);

};

class map_iterator {
public:
  T_value&  current_value();

  T_value&  get_value();

  bool  IsEnd();

  bool  IsValid();

  bool  next();

  bool  opEquals(const map_iterator<T_key,T_value>&in);

  bool  opPostInc();

  bool  opPreInc();

  const  T_key& current_key();

  const  T_key& get_key();

  map_iterator<T_key,T_value>&  opAssign(const map_iterator<T_key,T_value>&in);

  void  set_value(const T_value&in);

};


class minkowski2d : public shape2d {
public:

   minkowski2d(const shape2d@ a, const shape2d@ b);

};


class minkowski3d : public solid {
public:

   minkowski3d(const solid@ a, const solid@ b);

};


class mirror : public tmatrix {
public:

   mirror(double dx, double dy, double dz);


   mirror(vec3d@ normal, pos3d@ point = pos3d ( 0 , 0 , 0 ));


  double  dx() const;


  double  dy() const;


  double  dz() const;

};


class offset2d : public shape2d {
public:

   offset2d(const shape2d@ profile, double r = 0x7fc00000, double delta = 0x7fc00000, bool chamfer = false);


   offset2d(array<shape2d@>@ arr, double r = 0x7fc00000, double delta = 0x7fc00000, bool chamfer = false);

};


class pface {
public:

   pface(uint iv1, uint iv2, uint iv3);


   pface(uint iv1, uint iv2, uint iv3, uint iv4);


  uint  nvert() const;


  uint  vindex(uint iv) const;

};

class pointcloud {
public:
   pointcloud(array<pos3d@>@ points);

   pointcloud(string file, int skip_lines = 0, int xtok = 0, int ytok = 1, int ztok = 2, string delimiters = ' ,;   
');

  pos3d*[]@  points_array() const;

  uint  size() const;

};


class polygon : public shape2d {
public:

   polygon(const pos2d@ p1, const pos2d@ p2, const pos2d@ p3);


   polygon(const pos2d@ p1, const pos2d@ p2, const pos2d@ p3, const pos2d@ p4);


   polygon(const pos2d@ p1, const pos2d@ p2, const pos2d@ p3, const pos2d@ p4, const pos2d@ p5);


   polygon(const spline2d@ spline, uint nseg = 30);


   polygon(double r, uint np);


   polygon(array<pos2d@>@ points, bool check = true);


  double  area() const;


  double  signed_area() const;


  pos2d@  vertex(uint iv) const;


  uint  size() const;

};


class polyhedron : public solid {
public:

   polyhedron(array<pos3d@>@ points);


   polyhedron(array<pos3d@>@ points, array<pface@>@ faces);


   polyhedron(string file, int id = - 1);


  double  face_area(uint iface) const;


  double  volume() const;


  pface@  face(uint iface) const;


  pos3d@  vertex(uint iv) const;


  uint  nface() const;


  uint  nvert() const;


  void  flip_face(uint iface);

  void  flip_faces();


  void  set_vertex(uint iv, pos3d@ pos);

  void  verify() const;

};


class pos2d {
public:

   pos2d(const pos2d@ other);


   pos2d(double x, double y);


  double  dist(const pos2d@ pos) const;


  double  x() const;


  double  y() const;


  pos2d@  opAdd(pos2d@ p1);


  pos2d@  opAdd(vec2d@ v1);


  pos2d@  opAdd_r(vec2d@ v1);


  pos2d@  opMul(double f1);


  pos2d@  opMul_r(double f1);


  pos2d@  opSub(vec2d@ v1);

};


class pos3d {
public:

   pos3d(const pos3d@ other);


   pos3d(double x, double y, double z);


  double  dist(const pos3d@ pos) const;


  double  x() const;


  double  y() const;


  double  z() const;


  pos3d@  opAdd(pos3d@ p1);


  pos3d@  opAdd(vec3d@ v1);


  pos3d@  opAdd_r(vec3d@ v1);


  pos3d@  opMul(double f1);


  pos3d@  opMul_r(double f1);


  pos3d@  opSub(vec3d@ v1);

};

class projection2d : public shape2d {
public:
   projection2d(const solid@ s);

};


class rectangle : public shape2d {
public:

   rectangle(double dx, double dy, bool center = false);


  double  dx() const;


  double  dy() const;

};


class rotate_extrude : public solid {
public:

   rotate_extrude(const shape2d@ shape, double deg, double pitch = 0.0);


  double  deg() const;


  double  rad() const;

};


class rotate_x : public tmatrix {
public:

   rotate_x(double deg = 0x7fc00000, double rad = 0x7fc00000);


  double  deg() const;


  double  rad() const;

};


class rotate_y : public tmatrix {
public:

   rotate_y(double deg = 0x7fc00000, double rad = 0x7fc00000);


  double  deg() const;


  double  rad() const;

};


class rotate_z : public tmatrix {
public:

   rotate_z(double deg = 0x7fc00000, double rad = 0x7fc00000);


  double  deg() const;


  double  rad() const;

};


class scale : public tmatrix {
public:

   scale(double s);


   scale(double sx, double sy, double sz = 1.0);


  double  sx() const;


  double  sy() const;


  double  sz() const;

};

class shape {
public:

  boundingbox@  box() const;


  tmatrix@  transform() const;


  void  write_csg(string path);


  void  write_xcsg(string path, double secant_tolerance = - 1.0);

};


class shape2d : public shape {
public:

  shape2d@  opAdd(shape2d@ b);


  shape2d@  opAnd(shape2d@ b);


  shape2d@  opMul(tmatrix@ matrix);


  shape2d@  opSub(shape2d@ b);

};


class solid : public shape {
public:

  solid@  opAdd(solid@ b);


  solid@  opAnd(solid@ b);


  solid@  opMul(tmatrix@ matrix);


  solid@  opSub(solid@ b);

};


class sphere : public solid {
public:

   sphere(double r);


  double  r() const;


  double  radius() const;

};


class spline2d {
public:

   spline2d(array<pos2d@>@ points);

  pos2d@  pos(double t) const;

  vec2d@  dir(double t) const;

};


class spline3d {
public:

   spline3d(array<pos3d@>@ points);

  pos3d@  pos(double t) const;

  vec3d@  dir(double t) const;

};


class spline_path {
public:

   spline_path(array<pos3d@>@ p, array<vec3d@>@ v);


   spline_path(array<pos3d@>@ p, vec3d@ v);

};


class square : public shape2d {
public:

   square(double size, bool center = false);


  double  size() const;

};

class string {
public:
  bool  empty() const;

  bool  isEmpty() const;

  bool  opEquals(const string&in) const;

  const  uint8& opIndex(uint) const;

  int  find(const string&in, uint start = 0) const;

  int  findFirst(const string&in, uint start = 0) const;

  int  findFirstNotOf(const string&in, uint start = 0) const;

  int  findFirstOf(const string&in, uint start = 0) const;

  int  findLast(const string&in, int start = - 1) const;

  int  findLastNotOf(const string&in, int start = - 1) const;

  int  findLastOf(const string&in, int start = - 1) const;

  int  opCmp(const string&in) const;

  int  rfind(const string&in, int start = - 1) const;

  string&  opAddAssign(bool);

  string&  opAddAssign(const string&in);

  string&  opAddAssign(double);

  string&  opAddAssign(float);

  string&  opAddAssign(int64);

  string&  opAddAssign(uint64);

  string&  opAssign(bool);

  string&  opAssign(const string&in);

  string&  opAssign(double);

  string&  opAssign(float);

  string&  opAssign(int64);

  string&  opAssign(uint64);

  string  opAdd(bool) const;

  string  opAdd(const string&in) const;

  string  opAdd(double) const;

  string  opAdd(float) const;

  string  opAdd(int64) const;

  string  opAdd(uint64) const;

  string  opAdd_r(bool) const;

  string  opAdd_r(double) const;

  string  opAdd_r(float) const;

  string  opAdd_r(int64) const;

  string  opAdd_r(uint64) const;

  string  substr(uint start = 0, int count = - 1) const;

  uint8&  opIndex(uint);

  uint  length() const;

  uint  size() const;

  void  erase(uint pos, int count = - 1);

  void  insert(uint pos, const string&in other);

  void  resize(uint);

};


class sweep : public solid {
public:

   sweep(const shape2d@ shape, const spline_path@ path);

};


class tmatrix {
public:

  pos2d@  opMul(pos2d@ obj);


  pos3d@  opMul(pos3d@ obj);


  pos3d@  origin() const;


  shape2d@  opMul(shape2d@ obj);


  solid@  opMul(solid@ obj);


  tmatrix@  opMul(const tmatrix@ B);


  vec3d@  xdir() const;


  vec3d@  ydir() const;


  vec3d@  zdir() const;

  void  dump() const;

};


class transform_extrude : public solid {
public:

   transform_extrude(const shape2d@ bottom, const shape2d@ top);

};


class translate : public tmatrix {
public:

   translate(const vec3d@ v);


   translate(double dx, double dy, double dz = 0.0);


  double  dx() const;


  double  dy() const;


  double  dz() const;

};


class union2d : public shape2d {
public:

   union2d(const shape2d@ s1, const shape2d@ s2);


   union2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3);


   union2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3, const shape2d@ s4);


   union2d(const shape2d@ s1, const shape2d@ s2, const shape2d@ s3, const shape2d@ s4, const shape2d@ s5);

   union2d(array<shape2d@>@ arr);

};


class union3d : public solid {
public:

   union3d(const solid@ s1, const solid@ s2);


   union3d(const solid@ s1, const solid@ s2, const solid@ s3);


   union3d(const solid@ s1, const solid@ s2, const solid@ s3, const solid@ s4);


   union3d(const solid@ s1, const solid@ s2, const solid@ s3, const solid@ s4, const solid@ s5);

   union3d(array<solid@>@ arr);

};


class vec2d {
public:

   vec2d(const pos2d@ p1, const pos2d@ p2);


   vec2d(const vec2d@ other);


   vec2d(double x, double y);


  double  angle(const vec2d@ other) const;


  double  cross(const vec2d@ other) const;


  double  dot(const vec2d@ other) const;


  double  length() const;


  double  x() const;


  double  y() const;


  vec2d@  opAdd(vec2d@ v1);


  vec2d@  opMul(double f1);


  vec2d@  opMul_r(double f1);


  vec2d@  opSub(vec2d@ v1);

  void  normalise();

};


class vec3d {
public:

   vec3d(const pos3d@ p1, const pos3d@ p2);


   vec3d(const vec3d@ other);


   vec3d(double x, double y, double z);


  double  angle(const vec3d@ other) const;


  double  dot(const vec3d@ other) const;


  double  length() const;


  double  x() const;


  double  y() const;


  double  z() const;


  vec3d@  cross(const vec3d@ other) const;


  vec3d@  opAdd(vec3d@ v1);


  vec3d@  opMul(double f1);


  vec3d@  opMul_r(double f1);


  vec3d@  opSub(vec3d@ v1);

  void  normalise();

};