PrusaSlicer-NonPlainar/xs/xsp/Point.xsp

%module{Slic3r::XS};

%{
#include <xsinit.h>
#include "libslic3r/Point.hpp"
#include "libslic3r/Line.hpp"
#include "libslic3r/Polygon.hpp"
#include "libslic3r/Polyline.hpp"
%}

%name{Slic3r::Point} class Point {
    Point(int _x = 0, int _y = 0);
    ~Point();
    Clone<Point> clone()
        %code{% RETVAL=THIS; %}; 
    void scale(double factor)
        %code{% *THIS *= factor; %};
    void translate(double x, double y)
        %code{% *THIS += Point(x, y); %};
    SV* arrayref()
        %code{% RETVAL = to_SV_pureperl(THIS); %};
    SV* pp()
        %code{% RETVAL = to_SV_pureperl(THIS); %};
    int x()
        %code{% RETVAL = THIS->x(); %};
    int y()
        %code{% RETVAL = THIS->y(); %};
    void set_x(int val)
        %code{% THIS->x() = val; %};
    void set_y(int val)
        %code{% THIS->y() = val; %};
    int nearest_point_index(Points points);
    Clone<Point> nearest_point(Points points)
        %code{% Point p; THIS->nearest_point(points, &p); RETVAL = p; %};
    double distance_to(Point* point)
        %code{% RETVAL = (*point - *THIS).cast<double>().norm(); %};
    double distance_to_line(Line* line)
        %code{% RETVAL = line->distance_to(*THIS); %};
    double perp_distance_to_line(Line* line)
        %code{% RETVAL = line->perp_distance_to(*THIS); %};
    double ccw(Point* p1, Point* p2)
        %code{% RETVAL = THIS->ccw(*p1, *p2); %};
    double ccw_angle(Point* p1, Point* p2)
        %code{% RETVAL = THIS->ccw_angle(*p1, *p2); %};
    Point* projection_onto_polygon(Polygon* polygon)
        %code{% RETVAL = new Point(THIS->projection_onto(*polygon)); %};
    Point* projection_onto_polyline(Polyline* polyline)
        %code{% RETVAL = new Point(THIS->projection_onto(*polyline)); %};
    Point* projection_onto_line(Line* line)
        %code{% RETVAL = new Point(THIS->projection_onto(*line)); %};
    Point* negative()
        %code{% RETVAL = new Point(- *THIS); %};
    bool coincides_with_epsilon(Point* point)
        %code{% RETVAL = (*THIS) == *point; %};
    std::string serialize() %code{% char buf[2048]; sprintf(buf, "%ld,%ld", THIS->x(), THIS->y()); RETVAL = buf; %};

%{

void
Point::rotate(angle, center_sv)
    double  angle;
    SV*     center_sv;
    CODE:
        Point center;
        from_SV_check(center_sv, &center);
        THIS->rotate(angle, center);

bool
Point::coincides_with(point_sv)
    SV*     point_sv;
    CODE:
        Point point;
        from_SV_check(point_sv, &point);
        RETVAL = (*THIS) == point;
    OUTPUT:
        RETVAL

%}

};

%name{Slic3r::Point3} class Point3 {
    Point3(int _x = 0, int _y = 0, int _z = 0);
    ~Point3();
    Clone<Point3> clone()
        %code{% RETVAL = THIS; %};
    int x()
        %code{% RETVAL = THIS->x(); %};
    int y()
        %code{% RETVAL = THIS->y(); %};
    int z()
        %code{% RETVAL = THIS->z(); %};
    std::string serialize() %code{% char buf[2048]; sprintf(buf, "%ld,%ld,%ld", THIS->x(), THIS->y(), THIS->z()); RETVAL = buf; %};
};

%name{Slic3r::Pointf} class Pointf {
    Pointf(double _x = 0, double _y = 0);
    ~Pointf();
    Clone<Pointf> clone()
        %code{% RETVAL = THIS; %};
    SV* arrayref()
        %code{% RETVAL = to_SV_pureperl(THIS); %};
    SV* pp()
        %code{% RETVAL = to_SV_pureperl(THIS); %};
    double x()
        %code{% RETVAL = THIS->x(); %};
    double y()
        %code{% RETVAL = THIS->y(); %};
    void set_x(double val)
        %code{% THIS->x() = val; %};
    void set_y(double val)
        %code{% THIS->y() = val; %};
    void translate(double x, double y)
        %code{% *THIS += Pointf(x, y); %};
    void scale(double factor)
        %code{% *THIS *= factor; %};
    void rotate(double angle, Pointf* center)
        %code{% THIS->rotate(angle, *center); %};
    Pointf* negative()
        %code{% RETVAL = new Pointf(- *THIS); %};
    Pointf* vector_to(Pointf* point)
        %code{% RETVAL = new Pointf(*point - *THIS); %};
    std::string serialize() %code{% char buf[2048]; sprintf(buf, "%lf,%lf", THIS->x(), THIS->y()); RETVAL = buf; %};
};

%name{Slic3r::Pointf3} class Pointf3 {
    Pointf3(double _x = 0, double _y = 0, double _z = 0);
    ~Pointf3();
    Clone<Pointf3> clone()
        %code{% RETVAL = THIS; %};
    double x()
        %code{% RETVAL = THIS->x(); %};
    double y()
        %code{% RETVAL = THIS->y(); %};
    double z()
        %code{% RETVAL = THIS->z(); %};
    void set_x(double val)
        %code{% THIS->x() = val; %};
    void set_y(double val)
        %code{% THIS->y() = val; %};
    void set_z(double val)
        %code{% THIS->z() = val; %};
    void translate(double x, double y, double z)
        %code{% *THIS += Pointf3(x, y, z); %};
    void scale(double factor)
        %code{% *THIS *= factor; %};
    double distance_to(Pointf3* point)
        %code{% RETVAL = (*point - *THIS).norm(); %};
    Pointf3* negative()
        %code{% RETVAL = new Pointf3(- *THIS); %};
    Pointf3* vector_to(Pointf3* point)
        %code{% RETVAL = new Pointf3(*point - *THIS); %};
    std::string serialize() %code{% char buf[2048]; sprintf(buf, "%lf,%lf,%lf", THIS->x(), THIS->y(), THIS->z()); RETVAL = buf; %};
};