Slic3r::AnycubicSLAArchive Class Reference

#include <src/libslic3r/Format/AnycubicSLA.hpp>

Inheritance diagram for Slic3r::AnycubicSLAArchive:

Collaboration diagram for Slic3r::AnycubicSLAArchive:

Public Member Functions
	AnycubicSLAArchive ()=default
	AnycubicSLAArchive (const SLAPrinterConfig &cfg)
	AnycubicSLAArchive (SLAPrinterConfig &&cfg)
	AnycubicSLAArchive (const SLAPrinterConfig &cfg, uint16_t version)
	AnycubicSLAArchive (SLAPrinterConfig &&cfg, uint16_t version)
void	export_print (const std::string fname, const SLAPrint &print, const ThumbnailsList &thumbnails, const std::string &projectname="") override
template<class Fn , class CancelFn , class EP = ExecutionTBB>
void	draw_layers (size_t layer_num, Fn &&drawfn, CancelFn cancelfn=[]() { return false;}, const EP &ep={})

Static Public Member Functions
static std::unique_ptr< SLAArchiveWriter >	create (const std::string &archtype, const SLAPrinterConfig &)

Protected Member Functions
std::unique_ptr< sla::RasterBase >	create_raster () const override
sla::RasterEncoder	get_encoder () const override
SLAPrinterConfig &	cfg ()
const SLAPrinterConfig &	cfg () const

Protected Attributes
std::vector< sla::EncodedRaster >	m_layers

Private Attributes
SLAPrinterConfig	m_cfg
uint16_t	m_version

Detailed Description

Constructor & Destructor Documentation

AnycubicSLAArchive() [1/5]

Slic3r::AnycubicSLAArchive::AnycubicSLAArchive ( )

default

AnycubicSLAArchive() [2/5]

Slic3r::AnycubicSLAArchive::AnycubicSLAArchive ( const SLAPrinterConfig &  cfg )

inlineexplicit

                                                            :
        m_cfg(cfg), m_version(ANYCUBIC_SLA_FORMAT_VERSION_1) {}

AnycubicSLAArchive() [3/5]

Slic3r::AnycubicSLAArchive::AnycubicSLAArchive ( SLAPrinterConfig &&  cfg )

inlineexplicit

                                                       :
        m_cfg(std::move(cfg)), m_version(ANYCUBIC_SLA_FORMAT_VERSION_1) {}

AnycubicSLAArchive() [4/5]

Slic3r::AnycubicSLAArchive::AnycubicSLAArchive ( const SLAPrinterConfig &  cfg, uint16_t  version  )

inlineexplicit

                                                                              :
        m_cfg(cfg), m_version(version) {}

AnycubicSLAArchive() [5/5]

Slic3r::AnycubicSLAArchive::AnycubicSLAArchive ( SLAPrinterConfig &&  cfg, uint16_t  version  )

inlineexplicit

                                                                         :
        m_cfg(std::move(cfg)), m_version(version) {}

Member Function Documentation

cfg() [1/2]

SLAPrinterConfig & Slic3r::AnycubicSLAArchive::cfg ( )

inlineprotected

{ return m_cfg; }

References m_cfg.

cfg() [2/2]

const SLAPrinterConfig & Slic3r::AnycubicSLAArchive::cfg ( ) const

inlineprotected

{ return m_cfg; }

References m_cfg.

create()

std::unique_ptr< SLAArchiveWriter > Slic3r::SLAArchiveWriter::create ( const std::string &  archtype, const SLAPrinterConfig &  cfg  )

staticinherited

{
    std::unique_ptr<SLAArchiveWriter> ret;
    auto factory = get_writer_factory(archtype.c_str());
 
    if (factory)
        ret = factory(cfg);
 
    return ret;
}

References Slic3r::get_writer_factory().

Referenced by Slic3r::SLAPrint::apply().

Here is the call graph for this function:

Here is the caller graph for this function:

create_raster()

std::unique_ptr< sla::RasterBase > Slic3r::AnycubicSLAArchive::create_raster ( ) const

overrideprotectedvirtual

Implements Slic3r::SLAArchiveWriter.

{
    sla::Resolution     res;
    sla::PixelDim       pxdim;
    std::array<bool, 2> mirror;
 
    double w  = m_cfg.display_width.getFloat();
    double h  = m_cfg.display_height.getFloat();
    auto   pw = size_t(m_cfg.display_pixels_x.getInt());
    auto   ph = size_t(m_cfg.display_pixels_y.getInt());
 
    mirror[X] = m_cfg.display_mirror_x.getBool();
    mirror[Y] = m_cfg.display_mirror_y.getBool();
 
    auto                         ro = m_cfg.display_orientation.getInt();
    sla::RasterBase::Orientation orientation =
        ro == sla::RasterBase::roPortrait ? sla::RasterBase::roPortrait :
                                            sla::RasterBase::roLandscape;
 
    if (orientation == sla::RasterBase::roPortrait) {
        std::swap(w, h);
        std::swap(pw, ph);
    }
 
    res   = sla::Resolution{pw, ph};
    pxdim = sla::PixelDim{w / pw, h / ph};
    sla::RasterBase::Trafo tr{orientation, mirror};
 
    double gamma = m_cfg.gamma_correction.getFloat();
 
    return sla::create_raster_grayscale_aa(res, pxdim, gamma, tr);
}

References Slic3r::sla::create_raster_grayscale_aa(), m_cfg, Slic3r::sla::RasterBase::roLandscape, Slic3r::sla::RasterBase::roPortrait, Slic3r::X, and Slic3r::Y.

Here is the call graph for this function:

draw_layers()

template<class Fn , class CancelFn , class EP = ExecutionTBB>

void Slic3r::SLAArchiveWriter::draw_layers ( size_t  layer_num, Fn &&  drawfn, CancelFn  cancelfn = []() { return false; }, const EP &  ep = {}  )

inlineinherited

                                 { return false; },
        const EP & ep       = {})
    {
        m_layers.resize(layer_num);
        execution::for_each(
            ep, size_t(0), m_layers.size(),
            [this, &drawfn, &cancelfn](size_t idx) {
                if (cancelfn()) return;
 
                sla::EncodedRaster &enc = m_layers[idx];
                auto                rst = create_raster();
                drawfn(*rst, idx);
                enc = rst->encode(get_encoder());
            },
            execution::max_concurrency(ep));
    }

export_print()

void Slic3r::AnycubicSLAArchive::export_print ( const std::string  fname, const SLAPrint &  print, const ThumbnailsList &  thumbnails, const std::string &  projectname = ""  )

overridevirtual

Implements Slic3r::SLAArchiveWriter.

{
    std::uint32_t layer_count = m_layers.size();
 
    anycubicsla_format_intro         intro = {};
    anycubicsla_format_header        header = {};
    anycubicsla_format_preview       preview = {};
    anycubicsla_format_layers_header layers_header = {};
    anycubicsla_format_misc          misc = {};
    std::vector<uint8_t>      layer_images;
    std::uint32_t             image_offset;
 
    assert(m_version == ANYCUBIC_SLA_FORMAT_VERSION_1);
 
    intro.version             = m_version;
    intro.area_num            = 4;
    intro.header_data_offset  = sizeof(intro);
    intro.preview_data_offset = sizeof(intro) + sizeof(header);
    intro.layer_data_offset   = intro.preview_data_offset + sizeof(preview);
    intro.image_data_offset = intro.layer_data_offset +
                              sizeof(layers_header) +
                              (sizeof(anycubicsla_format_layer) * layer_count);
 
    fill_header(header, misc, print, layer_count);
    fill_preview(preview, misc, thumbnails);
 
    try {
        // open the file and write the contents
        std::ofstream out;
        out.open(fname, std::ios::binary | std::ios::out | std::ios::trunc);
        anycubicsla_write_intro(out, intro);
        anycubicsla_write_header(out, header);
        anycubicsla_write_preview(out, preview);
 
        layers_header.payload_size = intro.image_data_offset - intro.layer_data_offset -
                        sizeof(layers_header.tag)  - sizeof(layers_header.payload_size);
        layers_header.layer_count = layer_count;
        anycubicsla_write_layers_header(out, layers_header);
 
        //layers
        layer_images.reserve(layer_count * LAYER_SIZE_ESTIMATE);
        image_offset = intro.image_data_offset;
        size_t i = 0;
        for (const sla::EncodedRaster &rst : m_layers) {
            anycubicsla_format_layer l;
            std::memset(&l, 0, sizeof(l));
            l.image_offset = image_offset;
            l.image_size = rst.size();
            if (i < header.bottom_layer_count) {
                l.exposure_time_s = header.bottom_exposure_time_s;
                l.layer_height_mm = misc.bottom_layer_height_mm;
                l.lift_distance_mm = misc.bottom_lift_distance_mm;
                l.lift_speed_mms = misc.bottom_lift_speed_mms;
            } else {
                l.exposure_time_s = header.exposure_time_s;
                l.layer_height_mm = header.layer_height_mm;
                l.lift_distance_mm = header.lift_distance_mm;
                l.lift_speed_mms = header.lift_speed_mms;
            }
            image_offset += l.image_size;
            anycubicsla_write_layer(out, l);
            // add the rle encoded layer image into the buffer
            const char* img_start = reinterpret_cast<const char*>(rst.data());
            const char* img_end = img_start + rst.size();
            std::copy(img_start, img_end, std::back_inserter(layer_images));
            i++;
        }
        const char* img_buffer = reinterpret_cast<const char*>(layer_images.data());
        out.write(img_buffer, layer_images.size());
        out.close();
    } catch(std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << e.what();
        // Rethrow the exception
        throw;
    }
 
}

References ANYCUBIC_SLA_FORMAT_VERSION_1, Slic3r::anycubicsla_write_header(), Slic3r::anycubicsla_write_intro(), Slic3r::anycubicsla_write_layer(), Slic3r::anycubicsla_write_layers_header(), Slic3r::anycubicsla_write_preview(), Slic3r::anycubicsla_format_intro::area_num, Slic3r::anycubicsla_format_header::bottom_exposure_time_s, Slic3r::anycubicsla_format_header::bottom_layer_count, Slic3r::anycubicsla_format_misc::bottom_layer_height_mm, Slic3r::anycubicsla_format_misc::bottom_lift_distance_mm, Slic3r::anycubicsla_format_misc::bottom_lift_speed_mms, error, Slic3r::anycubicsla_format_header::exposure_time_s, Slic3r::anycubicsla_format_layer::exposure_time_s, Slic3r::anycubicsla_format_intro::header_data_offset, Slic3r::anycubicsla_format_intro::image_data_offset, Slic3r::anycubicsla_format_layer::image_offset, Slic3r::anycubicsla_format_layer::image_size, Slic3r::anycubicsla_format_layers_header::layer_count, Slic3r::anycubicsla_format_intro::layer_data_offset, Slic3r::anycubicsla_format_header::layer_height_mm, Slic3r::anycubicsla_format_layer::layer_height_mm, LAYER_SIZE_ESTIMATE, Slic3r::anycubicsla_format_header::lift_distance_mm, Slic3r::anycubicsla_format_layer::lift_distance_mm, Slic3r::anycubicsla_format_header::lift_speed_mms, Slic3r::anycubicsla_format_layer::lift_speed_mms, Slic3r::SLAArchiveWriter::m_layers, m_version, Slic3r::anycubicsla_format_layers_header::payload_size, Slic3r::anycubicsla_format_intro::preview_data_offset, Slic3r::anycubicsla_format_layers_header::tag, and Slic3r::anycubicsla_format_intro::version.

Here is the call graph for this function:

get_encoder()

sla::RasterEncoder Slic3r::AnycubicSLAArchive::get_encoder ( ) const

overrideprotectedvirtual

Implements Slic3r::SLAArchiveWriter.

{
    return AnycubicSLARasterEncoder{};
}

Member Data Documentation

m_cfg

SLAPrinterConfig Slic3r::AnycubicSLAArchive::m_cfg

private

Referenced by cfg(), cfg(), and create_raster().

m_layers

std::vector<sla::EncodedRaster> Slic3r::SLAArchiveWriter::m_layers

protectedinherited

Referenced by export_print(), and Slic3r::SL1Archive::export_print().

m_version

uint16_t Slic3r::AnycubicSLAArchive::m_version

private

Referenced by export_print().

---

The documentation for this class was generated from the following files:

• src/libslic3r/Format/AnycubicSLA.hpp
• src/libslic3r/Format/AnycubicSLA.cpp