212 lines
6.7 KiB
Plaintext
212 lines
6.7 KiB
Plaintext
%module{Slic3r::XS};
|
|
|
|
%{
|
|
#include <myinit.h>
|
|
#include "TriangleMesh.hpp"
|
|
%}
|
|
|
|
%name{Slic3r::TriangleMesh} class TriangleMesh {
|
|
TriangleMesh();
|
|
~TriangleMesh();
|
|
Clone<TriangleMesh> clone()
|
|
%code{% RETVAL = THIS; %};
|
|
void ReadSTLFile(char* input_file);
|
|
void write_ascii(char* output_file);
|
|
void write_binary(char* output_file);
|
|
void ReadFromPerl(SV* vertices, SV* facets);
|
|
void repair();
|
|
void WriteOBJFile(char* output_file);
|
|
void scale(float factor);
|
|
void scale_xyz(std::vector<double> versor)
|
|
%code{% THIS->scale(versor); %};
|
|
void translate(float x, float y, float z);
|
|
void rotate_x(float angle);
|
|
void rotate_y(float angle);
|
|
void rotate_z(float angle);
|
|
void align_to_origin();
|
|
void rotate(double angle, Point* center);
|
|
TriangleMeshPtrs split();
|
|
void merge(TriangleMesh* mesh);
|
|
ExPolygons horizontal_projection()
|
|
%code{% THIS->horizontal_projection(RETVAL); %};
|
|
BoundingBoxf3* bounding_box()
|
|
%code{%
|
|
RETVAL = new BoundingBoxf3();
|
|
THIS->bounding_box(RETVAL);
|
|
%};
|
|
int facets_count()
|
|
%code{% RETVAL = THIS->stl.stats.number_of_facets; %};
|
|
void reset_repair_stats();
|
|
%{
|
|
|
|
SV*
|
|
TriangleMesh::stats()
|
|
CODE:
|
|
HV* hv = newHV();
|
|
(void)hv_stores( hv, "number_of_facets", newSViv(THIS->stl.stats.number_of_facets) );
|
|
(void)hv_stores( hv, "number_of_parts", newSViv(THIS->stl.stats.number_of_parts) );
|
|
(void)hv_stores( hv, "volume", newSVnv(THIS->stl.stats.volume) );
|
|
(void)hv_stores( hv, "degenerate_facets", newSViv(THIS->stl.stats.degenerate_facets) );
|
|
(void)hv_stores( hv, "edges_fixed", newSViv(THIS->stl.stats.edges_fixed) );
|
|
(void)hv_stores( hv, "facets_removed", newSViv(THIS->stl.stats.facets_removed) );
|
|
(void)hv_stores( hv, "facets_added", newSViv(THIS->stl.stats.facets_added) );
|
|
(void)hv_stores( hv, "facets_reversed", newSViv(THIS->stl.stats.facets_reversed) );
|
|
(void)hv_stores( hv, "backwards_edges", newSViv(THIS->stl.stats.backwards_edges) );
|
|
(void)hv_stores( hv, "normals_fixed", newSViv(THIS->stl.stats.normals_fixed) );
|
|
RETVAL = (SV*)newRV_noinc((SV*)hv);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
SV*
|
|
TriangleMesh::vertices()
|
|
CODE:
|
|
if (!THIS->repaired) CONFESS("vertices() requires repair()");
|
|
|
|
if (THIS->stl.v_shared == NULL)
|
|
stl_generate_shared_vertices(&(THIS->stl));
|
|
|
|
// vertices
|
|
AV* vertices = newAV();
|
|
av_extend(vertices, THIS->stl.stats.shared_vertices);
|
|
for (int i = 0; i < THIS->stl.stats.shared_vertices; i++) {
|
|
AV* vertex = newAV();
|
|
av_store(vertices, i, newRV_noinc((SV*)vertex));
|
|
av_extend(vertex, 2);
|
|
av_store(vertex, 0, newSVnv(THIS->stl.v_shared[i].x));
|
|
av_store(vertex, 1, newSVnv(THIS->stl.v_shared[i].y));
|
|
av_store(vertex, 2, newSVnv(THIS->stl.v_shared[i].z));
|
|
}
|
|
|
|
RETVAL = newRV_noinc((SV*)vertices);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
SV*
|
|
TriangleMesh::facets()
|
|
CODE:
|
|
if (!THIS->repaired) CONFESS("facets() requires repair()");
|
|
|
|
if (THIS->stl.v_shared == NULL)
|
|
stl_generate_shared_vertices(&(THIS->stl));
|
|
|
|
// facets
|
|
AV* facets = newAV();
|
|
av_extend(facets, THIS->stl.stats.number_of_facets);
|
|
for (int i = 0; i < THIS->stl.stats.number_of_facets; i++) {
|
|
AV* facet = newAV();
|
|
av_store(facets, i, newRV_noinc((SV*)facet));
|
|
av_extend(facet, 2);
|
|
av_store(facet, 0, newSVnv(THIS->stl.v_indices[i].vertex[0]));
|
|
av_store(facet, 1, newSVnv(THIS->stl.v_indices[i].vertex[1]));
|
|
av_store(facet, 2, newSVnv(THIS->stl.v_indices[i].vertex[2]));
|
|
}
|
|
|
|
RETVAL = newRV_noinc((SV*)facets);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
SV*
|
|
TriangleMesh::normals()
|
|
CODE:
|
|
if (!THIS->repaired) CONFESS("normals() requires repair()");
|
|
|
|
// normals
|
|
AV* normals = newAV();
|
|
av_extend(normals, THIS->stl.stats.number_of_facets);
|
|
for (int i = 0; i < THIS->stl.stats.number_of_facets; i++) {
|
|
AV* facet = newAV();
|
|
av_store(normals, i, newRV_noinc((SV*)facet));
|
|
av_extend(facet, 2);
|
|
av_store(facet, 0, newSVnv(THIS->stl.facet_start[i].normal.x));
|
|
av_store(facet, 1, newSVnv(THIS->stl.facet_start[i].normal.y));
|
|
av_store(facet, 2, newSVnv(THIS->stl.facet_start[i].normal.z));
|
|
}
|
|
|
|
RETVAL = newRV_noinc((SV*)normals);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
SV*
|
|
TriangleMesh::size()
|
|
CODE:
|
|
AV* size = newAV();
|
|
av_extend(size, 2);
|
|
av_store(size, 0, newSVnv(THIS->stl.stats.size.x));
|
|
av_store(size, 1, newSVnv(THIS->stl.stats.size.y));
|
|
av_store(size, 2, newSVnv(THIS->stl.stats.size.z));
|
|
RETVAL = newRV_noinc((SV*)size);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
SV*
|
|
TriangleMesh::slice(z)
|
|
std::vector<double>* z
|
|
CODE:
|
|
// convert doubles to floats
|
|
std::vector<float> z_f(z->begin(), z->end());
|
|
delete z;
|
|
|
|
std::vector<ExPolygons> layers;
|
|
TriangleMeshSlicer mslicer(THIS);
|
|
mslicer.slice(z_f, &layers);
|
|
|
|
AV* layers_av = newAV();
|
|
av_extend(layers_av, layers.size()-1);
|
|
for (unsigned int i = 0; i < layers.size(); i++) {
|
|
AV* expolygons_av = newAV();
|
|
av_extend(expolygons_av, layers[i].size()-1);
|
|
unsigned int j = 0;
|
|
for (ExPolygons::iterator it = layers[i].begin(); it != layers[i].end(); ++it) {
|
|
av_store(expolygons_av, j++, perl_to_SV_clone_ref(*it));
|
|
}
|
|
av_store(layers_av, i, newRV_noinc((SV*)expolygons_av));
|
|
}
|
|
RETVAL = (SV*)newRV_noinc((SV*)layers_av);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
void
|
|
TriangleMesh::cut(z, upper, lower)
|
|
float z;
|
|
TriangleMesh* upper;
|
|
TriangleMesh* lower;
|
|
CODE:
|
|
TriangleMeshSlicer mslicer(THIS);
|
|
mslicer.cut(z, upper, lower);
|
|
|
|
std::vector<double>
|
|
TriangleMesh::bb3()
|
|
CODE:
|
|
RETVAL.push_back(THIS->stl.stats.min.x);
|
|
RETVAL.push_back(THIS->stl.stats.min.y);
|
|
RETVAL.push_back(THIS->stl.stats.max.x);
|
|
RETVAL.push_back(THIS->stl.stats.max.y);
|
|
RETVAL.push_back(THIS->stl.stats.min.z);
|
|
RETVAL.push_back(THIS->stl.stats.max.z);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
Polygon*
|
|
TriangleMesh::convex_hull()
|
|
CODE:
|
|
RETVAL = new Polygon ();
|
|
THIS->convex_hull(RETVAL);
|
|
OUTPUT:
|
|
RETVAL
|
|
|
|
%}
|
|
};
|
|
|
|
%package{Slic3r::TriangleMesh};
|
|
|
|
%{
|
|
PROTOTYPES: DISABLE
|
|
|
|
std::string
|
|
hello_world()
|
|
CODE:
|
|
RETVAL = "Hello world!";
|
|
OUTPUT:
|
|
RETVAL
|
|
%}
|