Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp} Namespace Reference

Functions
bool	is_image_file (const boost::filesystem::path &path)
void	scan_dir (const boost::filesystem::path &dir, TextureSource source, std::vector< TextureLibraryEntry > &out)
void	scan_plugin_textures (std::vector< TextureLibraryEntry > &out)
bool	image_has_color (const wxImage &image)
bool	encode_color_png_bytes (const wxImage &image, std::vector< unsigned char > &out, std::string &error)
bool	encode_gray_png_bytes (const wxImage &image, std::vector< unsigned char > &out, std::string &error)
bool	encode_png_bytes (const wxImage &image, std::vector< unsigned char > &out, std::string &error)
wxImage	image_from_decoded (const DecodedHeightTexture &image, std::vector< unsigned char > &scratch)
std::vector< unsigned char >	read_file_bytes (const std::string &path)
bool	is_supported_height_map (const std::vector< unsigned char > &bytes)
std::optional< TextureLibraryEntry >	write_user_texture (const std::vector< unsigned char > &bytes, const std::string &stem, std::string &error)
std::vector< std::string >	recent_texture_names ()
void	store_recent_texture_names (std::vector< std::string > names)
void	sort_user_textures (std::vector< TextureLibraryEntry > &library)
bool	in_user_texture_dir (const std::string &path)

Variables
std::vector< TextureLibraryEntry >	g_library
bool	g_library_scanned = false
uint64_t	g_library_scan_generation = 0
std::atomic< uint64_t >	g_library_generation { 0 }
const char *const	RECENT_SECTION = "texture_displacement"
const char *const	RECENT_KEY = "recent_textures"
const size_t	RECENT_MAX = 200

Function Documentation

encode_color_png_bytes()

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::encode_color_png_bytes	(	const wxImage &	image,
		std::vector< unsigned char > &	out,
		std::string &	error )

{
    if (image.GetWidth() <= 0 || image.GetHeight() <= 0) {
        error = _u8L("The selected image is empty.");
        return false;
    }
    wxMemoryOutputStream stream;
    // Alpha would be lost on the way into DecodedHeightTexture anyway, and a partly transparent
    // texture reading as black relief is worse than reading as its own colour over the background.
    wxImage opaque = image;
    if (opaque.HasAlpha())
        opaque.ClearAlpha();
    if (!opaque.SaveFile(stream, wxBITMAP_TYPE_PNG)) {
        error = _u8L("Failed to prepare the texture for use.");
        return false;
    }
    const size_t size = size_t(stream.GetLength());
    out.resize(size);
    stream.CopyTo(out.data(), size);
    if (out.empty()) {
        error = _u8L("Failed to prepare the texture for use.");
        return false;
    }
    return true;
}

References _u8L, and encode_color_png_bytes().

Referenced by encode_color_png_bytes(), and encode_png_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_gray_png_bytes()

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::encode_gray_png_bytes	(	const wxImage &	image,
		std::vector< unsigned char > &	out,
		std::string &	error )

{
    const wxImage gray = image.ConvertToGreyscale();
    const int     w    = gray.GetWidth();
    const int     h    = gray.GetHeight();
    if (w <= 0 || h <= 0) {
        error = _u8L("The selected image is empty.");
        return false;
    }
 
    // wxImage always stores 3 bytes per pixel; after ConvertToGreyscale the three are equal.
    std::vector<uint8_t> pixels(size_t(w) * size_t(h));
    const unsigned char *rgb = gray.GetData();
    for (size_t i = 0; i < pixels.size(); ++i)
        pixels[i] = rgb[i * 3];
 
    const boost::filesystem::path tmp = boost::filesystem::temp_directory_path()
        / boost::filesystem::unique_path("orca_texdisp_%%%%%%%%.png");
    if (!Slic3r::png::write_gray_to_file(tmp.string(), size_t(w), size_t(h), pixels)) {
        error = _u8L("Failed to prepare the texture for use.");
        return false;
    }
 
    {
        std::ifstream ifs(tmp.string(), std::ios::binary);
        out.assign(std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>());
    }
    boost::system::error_code ec;
    boost::filesystem::remove(tmp, ec);
 
    if (out.empty()) {
        error = _u8L("Failed to prepare the texture for use.");
        return false;
    }
    return true;
}

References _u8L, encode_gray_png_bytes(), and Slic3r::png::write_gray_to_file().

Referenced by encode_gray_png_bytes(), and encode_png_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_png_bytes()

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::encode_png_bytes	(	const wxImage &	image,
		std::vector< unsigned char > &	out,
		std::string &	error )

{
    return image_has_color(image) ? encode_color_png_bytes(image, out, error)
                                  : encode_gray_png_bytes(image, out, error);
}

References encode_color_png_bytes(), encode_gray_png_bytes(), encode_png_bytes(), and image_has_color().

Referenced by encode_png_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

image_from_decoded()

wxImage Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::image_from_decoded	(	const DecodedHeightTexture &	image,
		std::vector< unsigned char > &	scratch )

{
    if (image.empty())
        return wxImage();
 
    const size_t n = size_t(image.width) * size_t(image.height);
    scratch.resize(n * 3);
    if (image.has_color())
        scratch.assign(image.rgb.begin(), image.rgb.end());
    else
        for (size_t i = 0; i < n; ++i)
            scratch[i * 3] = scratch[i * 3 + 1] = scratch[i * 3 + 2] = image.pixels[i];
 
    return wxImage(image.width, image.height, scratch.data(), /* static_data */ true);
}

References Slic3r::DecodedHeightTexture::empty(), Slic3r::DecodedHeightTexture::has_color(), Slic3r::DecodedHeightTexture::height, image_from_decoded(), Slic3r::DecodedHeightTexture::pixels, Slic3r::DecodedHeightTexture::rgb, and Slic3r::DecodedHeightTexture::width.

Referenced by image_from_decoded().

Here is the call graph for this function:

Here is the caller graph for this function:

image_has_color()

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::image_has_color

(

const wxImage &

image

)

{
    const unsigned char *rgb = image.GetData();
    if (rgb == nullptr)
        return false;
    const size_t n = size_t(image.GetWidth()) * size_t(image.GetHeight());
    for (size_t i = 0; i < n; ++i)
        if (rgb[i * 3] != rgb[i * 3 + 1] || rgb[i * 3 + 1] != rgb[i * 3 + 2])
            return true;
    return false;
}

References image_has_color().

Referenced by encode_png_bytes(), and image_has_color().

Here is the call graph for this function:

Here is the caller graph for this function:

in_user_texture_dir()

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::in_user_texture_dir

(

const std::string &

path

)

{
    const std::string dir = user_texture_dir();
    if (dir.empty())
        return false;
    boost::system::error_code ec;
    const bool                same = boost::filesystem::equivalent(boost::filesystem::path(path).parent_path(),
                                                                   boost::filesystem::path(dir), ec);
    return !ec && same;
}

References in_user_texture_dir(), and Slic3r::GUI::user_texture_dir().

Referenced by in_user_texture_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

is_image_file()

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::is_image_file

(

const boost::filesystem::path &

path

)

{
    std::string ext = path.extension().string();
    boost::algorithm::to_lower(ext);
    return ext == ".png" || ext == ".jpg" || ext == ".jpeg" || ext == ".bmp";
}

References is_image_file().

Referenced by is_image_file(), and scan_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

is_supported_height_map()

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::is_supported_height_map

(

const std::vector< unsigned char > &

bytes

)

{
    return !bytes.empty() && png::is_decodable_8bit_png(png::ReadBuf{ bytes.data(), bytes.size() });
}

References Slic3r::png::is_decodable_8bit_png(), and is_supported_height_map().

Referenced by is_supported_height_map().

Here is the call graph for this function:

Here is the caller graph for this function:

read_file_bytes()

std::vector< unsigned char > Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::read_file_bytes

(

const std::string &

path

)

{
    std::ifstream ifs(path, std::ios::binary);
    return std::vector<unsigned char>(std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>());
}

References read_file_bytes().

Referenced by read_file_bytes().

Here is the call graph for this function:

Here is the caller graph for this function:

recent_texture_names()

std::vector< std::string > Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::recent_texture_names

(

)

{
    std::vector<std::string> names;
    if (wxTheApp == nullptr) // headless or shutting down: there is no app config to read
        return names;
    if (wxGetApp().app_config == nullptr)
        return names;
    const std::string value = wxGetApp().app_config->get(RECENT_SECTION, RECENT_KEY);
    for (size_t begin = 0; begin <= value.size();) {
        const size_t end = std::min(value.find('/', begin), value.size());
        if (end > begin)
            names.push_back(value.substr(begin, end - begin));
        begin = end + 1;
    }
    return names;
}

References RECENT_KEY, RECENT_SECTION, and recent_texture_names().

Referenced by recent_texture_names(), and sort_user_textures().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_dir()

void Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::scan_dir	(	const boost::filesystem::path &	dir,
		TextureSource	source,
		std::vector< TextureLibraryEntry > &	out )

{
    boost::system::error_code ec;
    if (!boost::filesystem::is_directory(dir, ec))
        return;
 
    const size_t first = out.size();
    for (boost::filesystem::directory_iterator it(dir, ec), end; it != end && !ec; it.increment(ec)) {
        if (!boost::filesystem::is_regular_file(it->path(), ec) || !is_image_file(it->path()))
            continue;
        out.push_back({ it->path().stem().string(), it->path().string(), source });
    }
    std::sort(out.begin() + first, out.end(),
              [](const TextureLibraryEntry &a, const TextureLibraryEntry &b) { return a.name < b.name; });
}

References is_image_file(), and scan_dir().

Referenced by scan_dir().

Here is the call graph for this function:

Here is the caller graph for this function:

scan_plugin_textures()

void Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::scan_plugin_textures

(

std::vector< TextureLibraryEntry > &

out

)

{
    std::vector<TextureLibraryEntry> found;
    for (const ResourceTextureEntry &pack : PluginResourceTextures::instance().entries()) {
        std::string                    error;
        const std::vector<std::string> files =
            collect_resource_texture_files(pack.texture_dir, pack.plugin_root, error);
        if (!error.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "Texture pack '" << pack.display_name << "' was skipped: " << error;
            continue;
        }
        for (const std::string &file : files) {
            const boost::filesystem::path path(file);
            found.push_back({ path.stem().string(), file, TextureSource::Plugin, pack.display_name });
        }
    }
 
    std::stable_sort(found.begin(), found.end(), [](const TextureLibraryEntry &a, const TextureLibraryEntry &b) {
        if (a.pack_name != b.pack_name)
            return a.pack_name < b.pack_name;
        return a.name < b.name;
    });
    for (TextureLibraryEntry &entry : found)
        out.push_back(std::move(entry));
}

References Slic3r::collect_resource_texture_files(), Slic3r::PluginResourceTextures::instance(), Slic3r::GUI::Plugin, and scan_plugin_textures().

Referenced by scan_plugin_textures().

Here is the call graph for this function:

Here is the caller graph for this function:

sort_user_textures()

void Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::sort_user_textures

(

std::vector< TextureLibraryEntry > &

library

)

{
    const std::vector<std::string>       names = recent_texture_names();
    std::unordered_map<std::string, int> rank;
    for (size_t i = 0; i < names.size(); ++i)
        rank.emplace(names[i], int(i));
    const auto rank_of = [&rank](const TextureLibraryEntry &e) {
        const auto it = rank.find(boost::filesystem::path(e.path).filename().string());
        return it == rank.end() ? std::numeric_limits<int>::max() : it->second;
    };
    const auto first_user = std::find_if(library.begin(), library.end(),
                                         [](const TextureLibraryEntry &e) { return e.source == TextureSource::User; });
    const auto user_end   = std::find_if(first_user, library.end(),
                                         [](const TextureLibraryEntry &e) { return e.source != TextureSource::User; });
    std::stable_sort(first_user, user_end,
                     [&rank_of](const TextureLibraryEntry &a, const TextureLibraryEntry &b) { return rank_of(a) < rank_of(b); });
}

References recent_texture_names(), and sort_user_textures().

Referenced by sort_user_textures().

Here is the call graph for this function:

Here is the caller graph for this function:

store_recent_texture_names()

void Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::store_recent_texture_names

(

std::vector< std::string >

names

)

{
    if (wxTheApp == nullptr) // headless or shutting down: there is no app config to write
        return;
    if (wxGetApp().app_config == nullptr)
        return;
    if (names.size() > RECENT_MAX)
        names.resize(RECENT_MAX);
    std::string value;
    for (const std::string &name : names)
        value += (value.empty() ? "" : "/") + name;
    wxGetApp().app_config->set(RECENT_SECTION, RECENT_KEY, value);
}

References RECENT_KEY, RECENT_MAX, RECENT_SECTION, and store_recent_texture_names().

Referenced by store_recent_texture_names().

Here is the call graph for this function:

Here is the caller graph for this function:

write_user_texture()

std::optional< TextureLibraryEntry > Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::write_user_texture	(	const std::vector< unsigned char > &	bytes,
		const std::string &	stem,
		std::string &	error )

{
    const std::string user_dir = user_texture_dir();
    if (user_dir.empty()) {
        error = _u8L("Could not create the folder for imported textures.");
        return std::nullopt;
    }
 
    boost::filesystem::path dest = boost::filesystem::path(user_dir) / (stem + ".png");
    for (int i = 2; boost::filesystem::exists(dest); ++i)
        dest = boost::filesystem::path(user_dir) / (stem + " (" + std::to_string(i) + ").png");
 
    {
        boost::nowide::ofstream ofs(dest.string(), std::ios::binary);
        ofs.write(reinterpret_cast<const char *>(bytes.data()), std::streamsize(bytes.size()));
        if (!ofs.good()) {
            error = _u8L("Failed to save the imported texture.");
            return std::nullopt;
        }
    }
 
    texture_library(true); // pick the new file up
    const std::string dest_str = dest.string();
    for (const TextureLibraryEntry &e : g_library)
        if (e.path == dest_str)
            return e;
 
    error = _u8L("Failed to save the imported texture.");
    return std::nullopt;
}

References _u8L, g_library, Slic3r::GUI::texture_library(), Slic3r::GUI::user_texture_dir(), and write_user_texture().

Referenced by write_user_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

g_library

std::vector<TextureLibraryEntry> Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::g_library

Referenced by write_user_texture().

g_library_generation

std::atomic<uint64_t> Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::g_library_generation { 0 }

{ 0 };

g_library_scan_generation

uint64_t Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::g_library_scan_generation = 0

g_library_scanned

bool Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::g_library_scanned = false

RECENT_KEY

const char* const Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::RECENT_KEY = "recent_textures"

Referenced by recent_texture_names(), and store_recent_texture_names().

RECENT_MAX

const size_t Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::RECENT_MAX = 200

Referenced by store_recent_texture_names().

RECENT_SECTION

const char* const Slic3r::GUI::anonymous_namespace{TextureLibrary.cpp}::RECENT_SECTION = "texture_displacement"

Referenced by recent_texture_names(), and store_recent_texture_names().