void Model::DeleteObjTree(vector<Gtk::TreeModel::Path> &iter)
{
objtree.DeleteSelected (iter);
ClearGCode();
ClearLayers();
ModelChanged();
}
Model::~Model()
{
ClearLayers();
ClearGCode();
delete m_previewLayer;
preview_shapes.clear();
}
void wxGxMapView::OnSelectionChanged(IGxSelection* Selection, long nInitiator)
{
if(nInitiator == GetId())
return;
GxObjectArray* pGxObjectArray = m_pSelection->GetSelectedObjects();
if(pGxObjectArray == NULL || pGxObjectArray->size() == 0)
return;
IGxObject* pGxObj = pGxObjectArray->at(pGxObjectArray->size() - 1);
if(m_pParentGxObject == pGxObj)
return;
IGxDataset* pGxDataset = dynamic_cast<IGxDataset*>(pGxObj);
if(pGxDataset == NULL)
return;
wxGISDataset* pwxGISDataset = pGxDataset->GetDataset();
if(pwxGISDataset == NULL)
return;
wxGISEnumDatasetType type = pwxGISDataset->GetType();
wxGISLayer* pwxGISLayer = NULL;
switch(type)
{
case enumGISFeatureDataset:
pwxGISLayer = new wxGISFeatureLayer(pwxGISDataset);
break;
case enumGISRasterDataset:
pwxGISLayer = new wxGISRasterLayer(pwxGISDataset);
break;
default:
break;
}
if(pwxGISLayer)
pwxGISLayer->SetName(pGxObj->GetName());
//the pOGRLayer will live while IGxObject live. IGxObject( from IGxSelection ) store IwxGISDataset, and destroy it then catalog destroyed
wsDELETE(pwxGISDataset);
//OGRLayer* pOGRLayer = pwxGISDataset->GetDataset();
//if(pOGRLayer == NULL)
//{
// return;
//}
ClearLayers();
if(pwxGISLayer && pwxGISLayer->IsValid())
AddLayer(pwxGISLayer);//m_GISMap.
m_pParentGxObject = pGxObj;
wxGISMapView::Refresh();
}
void Model::ReadSVG(Glib::RefPtr<Gio::File> file)
{
if (is_calculating) return;
if (is_printing) return;
bool autoplace = settings.Misc.ShapeAutoplace;
string path = file->get_path();
FlatShape * svgshape = new FlatShape(path);
cerr << svgshape->info() << endl;
AddShape(NULL, svgshape, path, autoplace);
ClearLayers();
}
void Model::ModelChanged()
{
if (m_inhibit_modelchange) return;
//printer.update_temp_poll_interval(); // necessary?
if (!is_printing) {
CalcBoundingBoxAndCenter();
Infill::clearPatterns();
if ( layers.size()>0 || m_previewGCode.size()>0 || m_previewLayer ) {
ClearGCode();
ClearLayers();
}
setCurrentPrintingLine(0);
m_model_changed.emit();
}
}
UILayerManager::~UILayerManager()
{
ClearLayers();
removeFromParent();
}
wxGISMap::~wxGISMap(void)
{
//std::for_each(m_Layers.begin(), m_Layers.end(), wxDELETE);
ClearLayers();
}
void Model::ConvertToGCode()
{
if (is_calculating) {
return;
}
is_calculating=true;
// default:
settings.SelectExtruder(0);
Glib::TimeVal start_time;
start_time.assign_current_time();
gcode.clear();
GCodeState state(gcode);
Infill::clearPatterns();
Vector3d printOffset = settings.getPrintMargin();
double printOffsetZ = printOffset.z();
// Make Layers
lastlayer = NULL;
Slice();
//CleanupLayers();
MakeShells();
if (settings.get_boolean("Slicing","DoInfill") &&
!settings.get_boolean("Slicing","NoTopAndBottom") &&
(settings.get_double("Slicing","SolidThickness") > 0 ||
settings.get_integer("Slicing","ShellCount") > 0))
// not bridging when support
MakeUncoveredPolygons( settings.get_boolean("Slicing","MakeDecor"),
!settings.get_boolean("Slicing","NoBridges") &&
!settings.get_boolean("Slicing","Support") );
if (settings.get_boolean("Slicing","Support"))
// easier before having multiplied uncovered bottoms
MakeSupportPolygons(settings.get_double("Slicing","SupportWiden"));
MakeFullSkins(); // must before multiplied uncovered bottoms
MultiplyUncoveredPolygons();
if (settings.get_boolean("Slicing","Skirt"))
MakeSkirt();
CalcInfill();
if (settings.get_boolean("Raft","Enable"))
{
printOffset += Vector3d (settings.get_double("Raft","Size"), 0);
MakeRaft (state, printOffsetZ); // printOffsetZ will have height of raft added
}
state.ResetLastWhere(Vector3d(0,0,0));
uint count = layers.size();
m_progress->start (_("Making Lines"), count+1);
state.AppendCommand(MILLIMETERSASUNITS, false, _("Millimeters"));
state.AppendCommand(ABSOLUTEPOSITIONING, false, _("Absolute Pos"));
if (settings.get_boolean("Slicing","RelativeEcode"))
state.AppendCommand(RELATIVE_ECODE, false, _("Relative E Code"));
else
state.AppendCommand(ABSOLUTE_ECODE, false, _("Absolute E Code"));
bool cont = true;
vector<PLine3> plines;
bool farthestStart = settings.get_boolean("Slicing","FarthestLayerStart");
Vector3d start = state.LastPosition();
for (uint p=0; p<count; p++) {
cont = (m_progress->update(p)) ;
if (!cont) break;
// cerr << "GCode layer " << (p+1) << " of " << count
// << " offset " << printOffsetZ
// << " have commands: " <<commands.size()
// << " start " << start << endl;;
// try {
if (farthestStart) {
// Vector2d randstart = layers[p]->getRandomPolygonPoint();
// start.set(randstart.x(), randstart.y());
const Vector2d fartheststart = layers[p]->getFarthestPolygonPoint(start);
start.set(fartheststart.x(), fartheststart.y());
}
layers[p]->MakePrintlines(start,
plines,
printOffsetZ,
settings);
// } catch (Glib::Error &e) {
// error("GCode Error:", (e.what()).c_str());
// }
// if (layers[p]->getPrevious() != NULL)
// cerr << p << ": " <<layers[p]->LayerNo << " prev: "
// << layers[p]->getPrevious()->LayerNo << endl;
}
// do antiooze retract for all lines:
Printlines::makeAntioozeRetract(plines, settings, m_progress);
vector<Command> commands;
//Printlines::getCommands(plines, settings, commands, m_progress);
Printlines::getCommands(plines, settings, state, m_progress);
//state.AppendCommands(commands, settings.Slicing.RelativeEcode);
string GcodeTxt;
if (cont)
gcode.MakeText (GcodeTxt, settings, m_progress);
else {
ClearLayers();
ClearGCode();
ClearPreview();
}
// display whole layer if flat shapes
// if (shapes.back()->dimensions() == 2)
// gcode.layerchanges.push_back(0);
m_progress->stop (_("Done"));
int h = (int)state.timeused/3600;
int m = ((int)state.timeused%3600)/60;
int s = ((int)state.timeused-3600*h-60*m);
std::ostringstream ostr;
ostr << _("Time Estimation: ") ;
if (h>0) ostr << h <<_("h") ;
ostr <<m <<_("m") <<s <<_("s") ;
double gctime = gcode.GetTimeEstimation();
if (abs(state.timeused - gctime) > 10) {
h = (int)(gctime/3600);
m = ((int)gctime)%3600/60;
s = (int)(gctime)-3600*h-60*m;
ostr << _(" / GCode Estimation: ");
if (h>0) ostr << h <<_("h");
ostr<< m <<_("m") << s <<_("s") ;
}
double totlength = gcode.GetTotalExtruded(settings.get_boolean("Slicing","RelativeEcode"));
ostr << _(" - total extruded: ") << totlength << "mm";
// TODO: ths assumes all extruders use the same filament diameter
const double diam = settings.get_double("Extruder","FilamentDiameter");
const double ccm = totlength * diam * diam / 4. * M_PI / 1000 ;
ostr << " = " << ccm << "cm^3 ";
ostr << "(ABS~" << ccm*1.08 << "g, PLA~" << ccm*1.25 << "g)";
if (statusbar)
statusbar->push(ostr.str());
else
cout << ostr.str() << endl;
{
Glib::TimeVal now;
now.assign_current_time();
const int time_used = (int) round((now - start_time).as_double()); // seconds
cerr << "GCode generated in " << time_used << " seconds. " << GcodeTxt.size() << " bytes" << endl;
}
is_calculating=false;
m_signal_gcode_changed.emit();
}
void Model::Slice()
{
vector<Shape*> shapes;
vector<Matrix4d> transforms;
if (settings.get_boolean("Slicing","SelectedOnly"))
objtree.get_selected_shapes(m_current_selectionpath, shapes, transforms);
else
objtree.get_all_shapes(shapes,transforms);
if (shapes.size() == 0) return;
assert(shapes.size() == transforms.size());
CalcBoundingBoxAndCenter(settings.get_boolean("Slicing","SelectedOnly"));
for (uint i = 0; i<transforms.size(); i++)
transforms[i] = settings.getBasicTransformation(transforms[i]);
assert(shapes.size() == transforms.size());
int LayerNr = 0;
bool varSlicing = settings.get_boolean("Slicing","Varslicing");
uint max_skins = max(1, settings.get_integer("Slicing","Skins"));
double thickness = (double)settings.get_double("Slicing","LayerThickness");
double skin_thickness = thickness / max_skins;
uint skins = max_skins; // probably variable
// - Start at z~=0, cut off everything below
// - Offset it a bit in Z, z = 0 gives a empty slice because no triangle crosses this Z value
double minZ = thickness * settings.get_double("Slicing","FirstLayerHeight");// + Min.z;
Vector3d volume = settings.getPrintVolume();
double maxZ = min(Max.z(), volume.z() - settings.getPrintMargin().z());
double max_gradient = 0;
double supportangle = settings.get_double("Slicing","SupportAngle")*M_PI/180.;
if (!settings.get_boolean("Slicing","Support")) supportangle = -1;
m_progress->set_terminal_output(settings.get_boolean("Display","TerminalProgress"));
m_progress->start (_("Slicing"), maxZ);
// for (vector<Layer *>::iterator pIt = layers.begin();
// pIt != layers. end(); pIt++)
// delete *pIt;
ClearLayers();
bool flatshapes = shapes.front()->dimensions() == 2;
if (flatshapes) {
layers.resize(1);
layers[0] = new Layer(lastlayer, 0, thickness , 1);
lastlayer = layers[0];
layers[0]->setZ(0); // set to real z
for (uint nshape= 0; nshape < shapes.size(); nshape++) {
layers[0]->addShape(transforms[nshape], *shapes[nshape], 0, max_gradient, -1);
}
return;
}
int progress_steps=max(1,(int)(maxZ/thickness/100.));
if ((varSlicing && skins > 1) ||
(settings.get_boolean("Slicing","BuildSerial") && shapes.size() > 1))
{
// have skins and/or serial build, so can't parallelise
uint currentshape = 0;
double serialheight = maxZ; // settings.Slicing.SerialBuildHeight;
double z = minZ;
double shape_z = z;
double max_shape_z = z + serialheight;
Layer * layer = new Layer(lastlayer, LayerNr, thickness, 1); // first layer no skins
layer->setZ(shape_z);
LayerNr = 1;
int new_polys=0;
bool cont = true;
while(cont && z < maxZ)
{
shape_z = z;
max_shape_z = min(shape_z + serialheight, maxZ);
while ( cont && currentshape < shapes.size() && shape_z <= max_shape_z ) {
if (LayerNr%progress_steps==0) cont = m_progress->update(shape_z);
layer->setZ(shape_z); // set to real z
if (shape_z == minZ) { // the layer is on the platform
layer->LayerNo = 0;
layer->setSkins(1);
LayerNr = 1;
}
new_polys = layer->addShape(transforms[currentshape], *shapes[currentshape],
shape_z, max_gradient, supportangle);
// cerr << "Z="<<z<<", shapez="<< shape_z << ", shape "<<currentshape
// << " of "<< shapes.size()<< " polys:" << new_polys<<endl;
if (shape_z >= max_shape_z) { // next shape, reset z
currentshape++;
shape_z = z;
} else { // next z, same shape
if (varSlicing && LayerNr!=0) {
// higher gradient -> slice thinner with fewer skin divisions
skins = max_skins-(uint)(max_skins* max_gradient);
thickness = skin_thickness*skins;
}
shape_z += thickness;
max_gradient = 0;
if (new_polys > -1){
layers.push_back(layer);
lastlayer = layer;
layer = new Layer(lastlayer, LayerNr++, thickness, skins);
}
}
}
//thickness = max_thickness-(max_thickness-min_thickness)*max_gradient;
if (currentshape < shapes.size()-1) { // reached max_shape_z, next shape
currentshape++;
} else { // end of shapes
if (new_polys > -1){
if (varSlicing) {
skins = max_skins-(uint)(max_skins* max_gradient);
thickness = skin_thickness*skins;
}
layers.push_back(layer);
lastlayer = layer;
layer = new Layer(lastlayer, LayerNr++, thickness, skins);
}
z = max_shape_z + thickness;
currentshape = 0; // all shapes again
}
max_gradient=0;
//cerr << " Z="<<z << "Max.z="<<Max.z<<endl;
}
delete layer; // have made one more than needed
return;
}
// simple case, can do multihreading
int num_layers = (int)ceil((maxZ - minZ) / thickness);
layers.resize(num_layers);
int nlayer;
bool cont = true;
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
for (nlayer = 0; nlayer < num_layers; nlayer++) {
double z = minZ + thickness * nlayer;
if (nlayer%progress_steps==0) {
#ifdef _OPENMP
#pragma omp critical(updateProgress)
{
cont = (m_progress->update(z));
#pragma omp flush (cont)
}
#else
cont = (m_progress->update(z));
#endif
}
#ifdef _OPENMP
#pragma omp flush (cont)
if (!cont) continue;
#else
if (!cont) break;
#endif
Layer * layer = new Layer(NULL, nlayer, thickness, nlayer>0?skins:1);
layer->setZ(z); // set to real z
for (uint nshape= 0; nshape < shapes.size(); nshape++) {
layer->addShape(transforms[nshape], *shapes[nshape],
z, max_gradient, supportangle);
}
layers[nlayer] = layer;
}
if (!cont)
ClearLayers();
#ifdef _OPENMP
//std::sort(layers.begin(), layers.end(), layersort);
#endif
for (uint nlayer = 1; nlayer < layers.size(); nlayer++) {
layers[nlayer]->setPrevious(layers[nlayer-1]);
assert(layers[nlayer]->Z > layers[nlayer-1]->Z);
}
if (layers.size()>0)
lastlayer = layers.back();
// shapes.clear();
//m_progress->stop (_("Done"));
}
void CSDLStateHandler::NewLayer( CSDLObjectQueueList* pLayer )
{
ClearLayers();
PushLayer( pLayer );
}
CSDLStateHandler::~CSDLStateHandler()
{
DebugInfo( TypeDelete, "Deleting state handler." );
ClearLayers();
}