void Model::ReadStl(Glib::RefPtr<Gio::File> file)
{
STL stl;
if (stl.loadFile (file->get_path()) == 0)
AddStl(NULL, stl, file->get_path());
ModelChanged();
}
void initMerge(int level, string inputSIF1, string inputSIF2, string inputSIF3){
makeWithSIF(glMesh1, inputSIF1);
makeWithSIF(glMesh2, inputSIF2);
makeWithSIF(glMesh3, inputSIF3);
Mesh glMesh12;
glMesh12 = merge(glMesh1, glMesh2);
glMesh = merge(glMesh12, glMesh3);
Subdivision myCC(glMesh);
glMesh = myCC.ccSubdivision(level);
glMesh.computeNormals();
Offset offset(glMesh, 0.0015);
vector<Mesh> meshes;
bool full = false;
if(full) {
offset.makeFullOffset();
glOffMesh = offset.offsetMesh;
Subdivision myOffCC(glOffMesh);
glOffMesh = myOffCC.ccSubdivision(0);
meshes.push_back(glOffMesh);
} else {
offset.makeSeperateOffset();
glPosMesh = offset.posOffsetMesh;
glNegMesh = offset.negOffsetMesh;
glSideMesh = offset.sideOffsetMesh;
meshes.push_back(glPosMesh);
meshes.push_back(glNegMesh);
meshes.push_back(glSideMesh);
}
STL stl;
stl.STLOutput(meshes, "debug/STL/Example.stl");
}
void init(int level, string inputSIF){
//makeWithSIF(glMesh, inputSIF);
makeWithQuadSIF(glMesh, inputSIF);
Subdivision myCC(glMesh);
glMesh = myCC.ccSubdivision(level);
glMesh.computeNormals();
Offset offset(glMesh, 0.0015);
vector<Mesh> meshes;
bool full = true;
if(full) {
offset.makeFullOffset();
glOffMesh = offset.offsetMesh;
Subdivision myOffCC(glOffMesh);
glOffMesh = myOffCC.ccSubdivision(0);
meshes.push_back(glOffMesh);
} else {
offset.makeSeperateOffset();
glPosMesh = offset.posOffsetMesh;
glNegMesh = offset.negOffsetMesh;
glSideMesh = offset.sideOffsetMesh;
meshes.push_back(glPosMesh);
meshes.push_back(glNegMesh);
meshes.push_back(glSideMesh);
}
STL stl;
stl.STLOutput(meshes, "debug/STL/Example.stl");
}
bool STLWriter::writeSTLFacets(const STL& stl, const bool& isBinaryMode)
{
for(size_t i = 0; i < stl.getFacets().size(); ++i)
{
if(!writeSTLFacet(stl.getFacetAt(i), isBinaryMode))
{
return false;
}
}
return true;
}
bool STLWriter::writeSTLHeader(const STL& stl, const bool& isBinaryMode)
{
if(isBinaryMode)
{
outputFile_.write("STLWRITER:THIS IS 80 BYTES OF CHARACTERSSTLWRITER:THIS IS 80 BYTES OF CHARACTERS",80);
unsigned long numTriangles = stl.getFacets().size();
outputFile_.write((char*)numTriangles, sizeof(unsigned long));
}
else
{
string name = "solid " + stl.getName() + "\n";
outputFile_.write(name.data(), name.length());
}
return true;
}
bool STLWriter::writeEndline(const STL& stl, const bool& isBinaryMode)
{
if(isBinaryMode)
{
string s = "endsolid " + stl.getName();
outputFile_.write(s.data(), s.length());
}
return true;
}
void ProcessController::ConvertToGCode(string &GcodeTxt, const string &GcodeStart, const string &GcodeLayer, const string &GcodeEnd)
{
if(gui)
{gui->ProgressBar->value(0);
gui->ProgressBar->label("Converting");
gui->ProgressBar->maximum(Max.z);
}
// Make Layers
uint LayerNr = 0;
printOffset = PrintMargin;
float z=Min.z+LayerThickness*0.5f; // Offset it a bit in Z, z=0 gives a empty slice because no triangles crosses this Z value
gcode.commands.clear();
float destinationZ=PrintMargin.z;
if(RaftEnable)
{
printOffset += Vector3f(RaftSize, RaftSize, 0);
MakeRaft(destinationZ);
}
float E=0.0f;
while(z<Max.z+LayerThickness*0.5f)
{
if(gui)
{
gui->ProgressBar->value(z);
gui->ProgressBar->redraw();
Fl::check();
}
for(uint o=0;o<rfo.Objects.size();o++)
for(uint f=0;f<rfo.Objects[o].files.size();f++)
{
STL* stl = &rfo.Objects[o].files[f].stl; // Get a pointer to the object
Matrix4f T = GetSTLTransformationMatrix(o,f);
Vector3f t = T.getTranslation();
t+= Vector3f(PrintMargin.x+RaftSize*RaftEnable, PrintMargin.y+RaftSize*RaftEnable, 0);
T.setTranslation(t);
CuttingPlane plane;
stl->CalcCuttingPlane(z, plane, T); // output is alot of un-connected line segments with individual vertices, describing the outline
float hackedZ = z;
while(plane.LinkSegments(hackedZ, ExtrudedMaterialWidth*0.5f, DisplayCuttingPlane, m_ShrinkQuality, ShellCount) == false) // If segment linking fails, re-calc a new layer close to this one, and use that.
{ // This happens when there's triangles missing in the input STL
hackedZ+= 0.1f;
plane.polygons.clear();
stl->CalcCuttingPlane(hackedZ, plane, T); // output is alot of un-connected line segments with individual vertices, describing the outline
}
// inFill
vector<Vector2f> infill;
CuttingPlane infillCuttingPlane = plane;
infillCuttingPlane.polygons = infillCuttingPlane.offsetPolygons;
infillCuttingPlane.vertices = infillCuttingPlane.offsetVertices;
infillCuttingPlane.offsetPolygons.clear();
infillCuttingPlane.offsetVertices.clear();
if(ShellOnly == false)
{
if(m_ShrinkQuality == SHRINK_FAST)
infillCuttingPlane.ShrinkFast(ExtrudedMaterialWidth*0.5f, z, DisplayCuttingPlane, false, ShellCount);
else
infillCuttingPlane.ShrinkNice(ExtrudedMaterialWidth*0.5f, z, DisplayCuttingPlane, false, ShellCount);
infillCuttingPlane.CalcInFill(infill, LayerNr, destinationZ, InfillDistance, InfillRotation, InfillRotationPrLayer, DisplayDebuginFill);
}
// Make the GCode from the plane and the infill
plane.MakeGcode(infill, gcode, E, destinationZ, MinPrintSpeedXY, MaxPrintSpeedXY, MinPrintSpeedZ, MaxPrintSpeedZ, DistanceToReachFullSpeed, extrusionFactor, UseIncrementalEcode, Use3DGcode, EnableAcceleration);
}
LayerNr++;
destinationZ += LayerThickness;
z+=LayerThickness;
}
GcodeTxt.clear();
gcode.MakeText(GcodeTxt, GcodeStart, GcodeLayer, GcodeEnd, UseIncrementalEcode, Use3DGcode);
gui->ProgressBar->label("Done");
}
void Model::ConvertToGCode()
{
string GcodeTxt;
string GcodeStart = settings.GCode.getStartText();
string GcodeLayer = settings.GCode.getLayerText();
string GcodeEnd = settings.GCode.getEndText();
PrintInhibitor inhibitPrint(this);
m_progress.start ("Converting", Max.z);
// Make Layers
uint LayerNr = 0;
uint LayerCount = (uint)ceil((Max.z+settings.Hardware.LayerThickness*0.5f)/settings.Hardware.LayerThickness);
vector<int> altInfillLayers;
settings.Slicing.GetAltInfillLayers (altInfillLayers, LayerCount);
printOffset = settings.Hardware.PrintMargin;
float z = Min.z + settings.Hardware.LayerThickness*0.5f; // Offset it a bit in Z, z=0 gives a empty slice because no triangles crosses this Z value
gcode.clear();
float printOffsetZ = settings.Hardware.PrintMargin.z;
if(settings.RaftEnable)
{
printOffset += Vector3f(settings.Raft.Size, settings.Raft.Size, 0);
MakeRaft(printOffsetZ);
}
float E=0.0f;
while(z<Max.z)
{
m_progress.update(z);
for(uint o=0;o<rfo.Objects.size();o++)
{
for(uint f=0;f<rfo.Objects[o].files.size();f++)
{
STL* stl = &rfo.Objects[o].files[f].stl; // Get a pointer to the object
Matrix4f T = rfo.GetSTLTransformationMatrix(o,f);
Vector3f t = T.getTranslation();
t+= Vector3f(settings.Hardware.PrintMargin.x+settings.Raft.Size*settings.RaftEnable, settings.Hardware.PrintMargin.y+settings.Raft.Size*settings.RaftEnable, 0);
T.setTranslation(t);
CuttingPlane plane;
stl->CalcCuttingPlane(z, plane, T); // output is alot of un-connected line segments with individual vertices, describing the outline
float hackedZ = z;
while (plane.LinkSegments (hackedZ, settings.Slicing.Optimization) == false) // If segment linking fails, re-calc a new layer close to this one, and use that.
{ // This happens when there's triangles missing in the input STL
hackedZ+= 0.1f;
stl->CalcCuttingPlane (hackedZ, plane, T); // output is alot of un-connected line segments with individual vertices
}
plane.SetZ (z + printOffsetZ);
// inFill
vector<Vector2f> infill;
// CuttingPlane infillCuttingPlane;
// plane.MakeContainedPlane(infillCuttingPlane);
if(settings.Slicing.ShellOnly == false)
{
switch( settings.Slicing.ShrinkQuality )
{
case SHRINK_FAST:
plane.ShrinkFast(settings.Hardware.ExtrudedMaterialWidth*0.5f, settings.Slicing.Optimization, settings.Display.DisplayCuttingPlane, false, settings.Slicing.ShellCount);
break;
case SHRINK_LOGICK:
plane.ShrinkLogick(settings.Hardware.ExtrudedMaterialWidth, settings.Slicing.Optimization, settings.Display.DisplayCuttingPlane, settings.Slicing.ShellCount);
break;
default:
g_warning ("unknown shrinking algorithm");
break;
}
// check if this if a layer we should use the alternate infill distance on
float infillDistance = settings.Slicing.InfillDistance;
if (std::find(altInfillLayers.begin(), altInfillLayers.end(), LayerNr) != altInfillLayers.end())
{
infillDistance = settings.Slicing.AltInfillDistance;
}
plane.CalcInFill(infill, LayerNr, infillDistance, settings.Slicing.InfillRotation, settings.Slicing.InfillRotationPrLayer, settings.Display.DisplayDebuginFill);
}
// Make the GCode from the plane and the infill
plane.MakeGcode (infill, gcode, E, z + printOffsetZ,
settings.Slicing, settings.Hardware);
}
}
LayerNr++;
z+=settings.Hardware.LayerThickness;
}
float AntioozeDistance = settings.Slicing.AntioozeDistance;
if (!settings.Slicing.EnableAntiooze)
AntioozeDistance = 0;
gcode.MakeText (GcodeTxt, GcodeStart, GcodeLayer, GcodeEnd,
settings.Slicing.UseIncrementalEcode,
settings.Slicing.Use3DGcode,
AntioozeDistance,
settings.Slicing.AntioozeSpeed);
m_progress.stop ("Done");
}
void ProcessController::ConvertToGCode(string &GcodeTxt, const string &GcodeStart, const string &GcodeLayer, const string &GcodeEnd)
{
if(gui)
{
gui->ProgressBar->value(0);
gui->ProgressBar->label("Converting");
gui->ProgressBar->maximum(Max.z);
}
// Make Layers
uint LayerNr = 0;
uint LayerCount = (uint)ceil((Max.z+LayerThickness*0.5f)/LayerThickness);
vector<int> altInfillLayers;
GetAltInfillLayers(altInfillLayers, LayerCount);
printOffset = PrintMargin;
float z=Min.z+LayerThickness*0.5f; // Offset it a bit in Z, z=0 gives a empty slice because no triangles crosses this Z value
gcode.commands.clear();
float printOffsetZ=PrintMargin.z;
if(RaftEnable)
{
printOffset += Vector3f(RaftSize, RaftSize, 0);
MakeRaft(printOffsetZ);
}
float E=0.0f;
while(z<Max.z)
{
if(gui)
{
gui->ProgressBar->value(z);
gui->ProgressBar->redraw();
Fl::check();
}
for(uint o=0;o<rfo.Objects.size();o++)
{
for(uint f=0;f<rfo.Objects[o].files.size();f++)
{
STL* stl = &rfo.Objects[o].files[f].stl; // Get a pointer to the object
Matrix4f T = GetSTLTransformationMatrix(o,f);
Vector3f t = T.getTranslation();
t+= Vector3f(PrintMargin.x+RaftSize*RaftEnable, PrintMargin.y+RaftSize*RaftEnable, 0);
T.setTranslation(t);
CuttingPlane plane;
stl->CalcCuttingPlane(z, plane, T); // output is alot of un-connected line segments with individual vertices, describing the outline
float hackedZ = z;
while (plane.LinkSegments (hackedZ, Optimization) == false) // If segment linking fails, re-calc a new layer close to this one, and use that.
{ // This happens when there's triangles missing in the input STL
hackedZ+= 0.1f;
stl->CalcCuttingPlane (hackedZ, plane, T); // output is alot of un-connected line segments with individual vertices
}
plane.SetZ (z + printOffsetZ);
// inFill
vector<Vector2f> infill;
// CuttingPlane infillCuttingPlane;
// plane.MakeContainedPlane(infillCuttingPlane);
if(ShellOnly == false)
{
switch( m_ShrinkQuality )
{
case SHRINK_FAST:
plane.ShrinkFast(ExtrudedMaterialWidth*0.5f, Optimization, DisplayCuttingPlane, false, ShellCount);
break;
case SHRINK_LOGICK:
plane.ShrinkLogick(ExtrudedMaterialWidth, Optimization, DisplayCuttingPlane, ShellCount);
break;
}
// check if this if a layer we should use the alternate infill distance on
float infillDistance = InfillDistance;
if (std::find(altInfillLayers.begin(), altInfillLayers.end(), LayerNr) != altInfillLayers.end())
{
infillDistance = AltInfillDistance;
}
plane.CalcInFill(infill, LayerNr, infillDistance, InfillRotation, InfillRotationPrLayer, DisplayDebuginFill);
}
// Make the GCode from the plane and the infill
plane.MakeGcode(infill, gcode, E, z+printOffsetZ, MinPrintSpeedXY, MaxPrintSpeedXY, MinPrintSpeedZ, MaxPrintSpeedZ, DistanceToReachFullSpeed, extrusionFactor, UseIncrementalEcode, Use3DGcode, EnableAcceleration);
}
}
LayerNr++;
z+=LayerThickness;
}
GcodeTxt.clear();
if (!EnableAntiooze)
{
AntioozeDistance = 0;
}
gcode.MakeText(GcodeTxt, GcodeStart, GcodeLayer, GcodeEnd, UseIncrementalEcode, Use3DGcode, AntioozeDistance, AntioozeSpeed);
gui->ProgressBar->label("Done");
}
