#include <src/libslic3r/ExtrusionSimulator.hpp>

Collaboration diagram for Slic3r::ExtrusionSimulator:

Public Member Functions
	ExtrusionSimulator ()

	~ExtrusionSimulator ()

void	set_image_size (const Point &image_size)

void	set_viewport (const BoundingBox &viewport)

void	set_bounding_box (const BoundingBox &bbox)

void	reset_accumulator ()

void	extrude_to_accumulator (const ExtrusionPath &path, const Point &shift, ExtrusionSimulationType simulationType)

void	evaluate_accumulator (ExtrusionSimulationType simulationType)

const void *	image_ptr () const

Private Attributes
Point	image_size

BoundingBox	viewport

BoundingBox	bbox

ExtrusionSimulatorImpl *	pimpl

Detailed Description

Constructor & Destructor Documentation

◆ ExtrusionSimulator()

Slic3r::ExtrusionSimulator::ExtrusionSimulator ( )

                                       :
  pimpl(new ExtrusionSimulatorImpl)
{
  pimpl->color_gradient = CreatePowerColorGradient24bit();
  pimpl->bitmap_oversampled = 4;
}

References Slic3r::ExtrusionSimulatorImpl::bitmap_oversampled, Slic3r::ExtrusionSimulatorImpl::color_gradient, Slic3r::CreatePowerColorGradient24bit(), and pimpl.

Here is the call graph for this function:

◆ ~ExtrusionSimulator()

Slic3r::ExtrusionSimulator::~ExtrusionSimulator ( )

{
  delete pimpl;
  pimpl = NULL;
}

References pimpl.

Member Function Documentation

◆ evaluate_accumulator()

void Slic3r::ExtrusionSimulator::evaluate_accumulator ( ExtrusionSimulationType simulationType )

{
  // printf("ExtrusionSimulator::evaluate_accumulator()\n");
  Point sz = viewport.size();
 
  if (simulationType > ExtrusionSimulationDontSpread) {
    // Average the cells of a bitmap into a lower resolution floating point mask.
    A2f mask(boost::extents[sz.y()][sz.x()]);
    for (int r = 0; r < sz.y(); ++r) {
      for (int c = 0; c < sz.x(); ++c) {
        float p = 0;
        for (unsigned int j = 0; j < pimpl->bitmap_oversampled; ++ j) {
          for (unsigned int i = 0; i < pimpl->bitmap_oversampled; ++ i) {
            if (pimpl->bitmap[r * pimpl->bitmap_oversampled + j][c * pimpl->bitmap_oversampled + i])
              p += 1.f;
          }
        }
        p /= float(pimpl->bitmap_oversampled * pimpl->bitmap_oversampled * 2);
        mask[r][c] = p;
      }
    }
 
    // Spread the excess of the material.
    gcode_spread_points(pimpl->accumulator, mask, pimpl->extrusion_points, simulationType);
  }
 
  // Color map the accumulator.
  for (int r = 0; r < sz.y(); ++r) {
    unsigned char *ptr = &pimpl->image_data[(image_size.x() * (viewport.min.y() + r) + viewport.min.x()) * 4];
    for (int c = 0; c < sz.x(); ++c) {
      #if 1
      float p   = pimpl->accumulator[r][c];
      #else
      float p = mask[r][c];
      #endif
      int   idx = int(floor(p * float(pimpl->color_gradient.size()) + 0.5f));
      V3uc  clr = pimpl->color_gradient[std::clamp(idx, 0, int(pimpl->color_gradient.size()-1))];
      *ptr ++ = clr.get<0>();
      *ptr ++ = clr.get<1>();
      *ptr ++ = clr.get<2>();
      *ptr ++ = (idx == 0) ? 0 : 255;
    }
  }
}

References Slic3r::ExtrusionSimulatorImpl::accumulator, Slic3r::ExtrusionSimulatorImpl::bitmap, Slic3r::ExtrusionSimulatorImpl::bitmap_oversampled, Slic3r::ExtrusionSimulatorImpl::color_gradient, Slic3r::ExtrusionSimulatorImpl::extrusion_points, Slic3r::ExtrusionSimulationDontSpread, floor(), Slic3r::gcode_spread_points(), Slic3r::ExtrusionSimulatorImpl::image_data, image_size, Slic3r::BoundingBoxBase< PointType, APointsType >::min, pimpl, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), and viewport.

Here is the call graph for this function:

◆ extrude_to_accumulator()

void Slic3r::ExtrusionSimulator::extrude_to_accumulator	(	const ExtrusionPath &	path,
		const Point &	shift,
		ExtrusionSimulationType	simulationType
	)

{
  // printf("Extruding a path. Nr points: %d, width: %f, height: %f\r\n", path.polyline.points.size(), path.width, path.height);
  // Convert the path to V2f points, shift and scale them to the viewport.
  std::vector<V2f> polyline;
  polyline.reserve(path.polyline.points.size());
  float scalex  = float(viewport.size().x()) / float(bbox.size().x());
  float scaley  = float(viewport.size().y()) / float(bbox.size().y());
  float w = scale_(path.width) * scalex;
  //float h = scale_(path.height) * scalex;
  w = scale_(path.mm3_per_mm / path.height) * scalex;
  // printf("scalex: %f, scaley: %f\n", scalex, scaley);
  // printf("bbox: %d,%d %d,%d\n", bbox.min.x(), bbox.min.y, bbox.max.x(), bbox.max.y);
  for (Points::const_iterator it = path.polyline.points.begin(); it != path.polyline.points.end(); ++ it) {
    // printf("point %d,%d\n", it->x+shift.x(), it->y+shift.y);
    ExtrusionPoint ept;
    ept.center = V2f(float((*it)(0)+shift.x()-bbox.min.x()) * scalex, float((*it)(1)+shift.y()-bbox.min.y()) * scaley);
    ept.radius = w/2.f;
    ept.height = 0.5f;
    polyline.push_back(ept.center);
    pimpl->extrusion_points.push_back(ept);
  }
  // Extrude the polyline into an accumulator.
  // printf("width scaled: %f, height scaled: %f\n", w, h);
  gcode_paint_layer(polyline, w, 0.5f, pimpl->accumulator);
 
  if (simulationType > ExtrusionSimulationDontSpread)
    gcode_paint_bitmap(polyline, w, pimpl->bitmap, pimpl->bitmap_oversampled);
    // double path.mm3_per_mm;  // mm^3 of plastic per mm of linear head motion
    // float path.width;
    // float path.height;
}

References Slic3r::ExtrusionSimulatorImpl::accumulator, bbox, Slic3r::ExtrusionSimulatorImpl::bitmap, Slic3r::ExtrusionSimulatorImpl::bitmap_oversampled, Slic3r::ExtrusionPoint::center, Slic3r::ExtrusionSimulatorImpl::extrusion_points, Slic3r::ExtrusionSimulationDontSpread, Slic3r::gcode_paint_bitmap(), Slic3r::gcode_paint_layer(), Slic3r::ExtrusionPath::height, Slic3r::ExtrusionPoint::height, Slic3r::BoundingBoxBase< PointType, APointsType >::min, Slic3r::ExtrusionPath::mm3_per_mm, pimpl, Slic3r::MultiPoint::points, Slic3r::ExtrusionPath::polyline, Slic3r::ExtrusionPoint::radius, scale_, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), viewport, and Slic3r::ExtrusionPath::width.

Here is the call graph for this function:

◆ image_ptr()

const void * Slic3r::ExtrusionSimulator::image_ptr ( ) const

{
  return (pimpl->image_data.empty()) ? NULL : (void*)&pimpl->image_data.front();
}

References Slic3r::ExtrusionSimulatorImpl::image_data, and pimpl.

◆ reset_accumulator()

void Slic3r::ExtrusionSimulator::reset_accumulator ( )

{
  // printf("ExtrusionSimulator::reset_accumulator()\n");
  Point sz = viewport.size();
  // printf("Reset accumulator, Accumulator size: %d, %d\n", sz.y, sz.x);
  memset(&pimpl->accumulator[0][0], 0, sizeof(float) * sz.x() * sz.y());
  memset(&pimpl->bitmap[0][0], 0, sz.x() * sz.y() * pimpl->bitmap_oversampled * pimpl->bitmap_oversampled);
  pimpl->extrusion_points.clear();
  // printf("Reset accumulator, done.\n");
}

References Slic3r::ExtrusionSimulatorImpl::accumulator, Slic3r::ExtrusionSimulatorImpl::bitmap, Slic3r::ExtrusionSimulatorImpl::bitmap_oversampled, Slic3r::ExtrusionSimulatorImpl::extrusion_points, pimpl, Slic3r::BoundingBoxBase< PointType, APointsType >::size(), and viewport.

Here is the call graph for this function:

◆ set_bounding_box()

void Slic3r::ExtrusionSimulator::set_bounding_box ( const BoundingBox & bbox )

{
  this->bbox = bbox;
}

References bbox.

◆ set_image_size()

void Slic3r::ExtrusionSimulator::set_image_size ( const Point & image_size )

{
  // printf("ExtrusionSimulator::set_image_size()\n");
  if (this->image_size.x() == image_size.x() &&
    this->image_size.y() == image_size.y())
    return;
 
  // printf("Setting image size: %d, %d\n", image_size.x, image_size.y);
  this->image_size = image_size;
  // Allocate the image data in an RGBA format.
  // printf("Allocating image data, size %d\n", image_size.x * image_size.y * 4);
  pimpl->image_data.assign(image_size.x() * image_size.y() * 4, 0);
  // printf("Allocating image data, allocated\n");
 
  //FIXME fill the image with red vertical lines.
  for (size_t r = 0; r < size_t(image_size.y()); ++ r) {
    for (size_t c = 0; c < size_t(image_size.x()); c += 2) {
      // Color red
      pimpl->image_data[r * image_size.x() * 4 + c * 4] = 255;
      // Opacity full
      pimpl->image_data[r * image_size.x() * 4 + c * 4 + 3] = 255;
    }
  }
  // printf("Allocating image data, set\n");
}

References Slic3r::ExtrusionSimulatorImpl::image_data, image_size, and pimpl.

◆ set_viewport()

void Slic3r::ExtrusionSimulator::set_viewport ( const BoundingBox & viewport )

{
  // printf("ExtrusionSimulator::set_viewport(%d, %d, %d, %d)\n", viewport.min.x, viewport.min.y, viewport.max.x, viewport.max.y);
  if (this->viewport != viewport) {
    this->viewport = viewport;
    Point sz = viewport.size();
    pimpl->accumulator.resize(boost::extents[sz.y()][sz.x()]);
    pimpl->bitmap.resize(boost::extents[sz.y()*pimpl->bitmap_oversampled][sz.x()*pimpl->bitmap_oversampled]);
    // printf("Accumulator size: %d, %d\n", sz.y, sz.x);
  }
}