documentation/3.0.1/Image_8hpp_source.html

//

// SFML - Simple and Fast Multimedia Library

// Copyright (C) 2007-2025 Laurent Gomila (laurent@sfml-dev.org)

//

// This software is provided 'as-is', without any express or implied warranty.

// In no event will the authors be held liable for any damages arising from the use of this software.

//

// Permission is granted to anyone to use this software for any purpose,

// including commercial applications, and to alter it and redistribute it freely,

// subject to the following restrictions:

//

// 1. The origin of this software must not be misrepresented;

//    you must not claim that you wrote the original software.

//    If you use this software in a product, an acknowledgment

//    in the product documentation would be appreciated but is not required.

//

// 2. Altered source versions must be plainly marked as such,

//    and must not be misrepresented as being the original software.

//

// 3. This notice may not be removed or altered from any source distribution.

//


#pragma once


// Headers

#include <SFML/Graphics/Export.hpp>


#include <SFML/Graphics/Color.hpp>

#include <SFML/Graphics/Rect.hpp>


#include <SFML/System/Vector2.hpp>


#include <filesystem>

#include <optional>

#include <string_view>

#include <vector>


#include <cstddef>

#include <cstdint>


namespace sf

{

class InputStream;


class SFML_GRAPHICS_API Image

{

public:

    Image() = default;


    explicit Image(Vector2u size, Color color = Color::Black);


    Image(Vector2u size, const std::uint8_t* pixels);


    explicit Image(const std::filesystem::path& filename);


    Image(const void* data, std::size_t size);


    explicit Image(InputStream& stream);


    void resize(Vector2u size, Color color = Color::Black);


    void resize(Vector2u size, const std::uint8_t* pixels);


    [[nodiscard]] bool loadFromFile(const std::filesystem::path& filename);


    [[nodiscard]] bool loadFromMemory(const void* data, std::size_t size);


    [[nodiscard]] bool loadFromStream(InputStream& stream);


    [[nodiscard]] bool saveToFile(const std::filesystem::path& filename) const;


    [[nodiscard]] std::optional<std::vector<std::uint8_t>> saveToMemory(std::string_view format) const;


    [[nodiscard]] Vector2u getSize() const;


    void createMaskFromColor(Color color, std::uint8_t alpha = 0);


    [[nodiscard]] bool copy(const Image& source, Vector2u dest, const IntRect& sourceRect = {}, bool applyAlpha = false);


    void setPixel(Vector2u coords, Color color);


    [[nodiscard]] Color getPixel(Vector2u coords) const;


    [[nodiscard]] const std::uint8_t* getPixelsPtr() const;


    void flipHorizontally();


    void flipVertically();


private:

    // Member data

    Vector2u                  m_size;

    std::vector<std::uint8_t> m_pixels;

};


} // namespace sf


Color.hpp

Export.hpp

SFML_GRAPHICS_API
#define SFML_GRAPHICS_API
Definition Graphics/Export.hpp:42

Rect.hpp

Vector2.hpp

sf::Color
Utility class for manipulating RGBA colors.
Definition Color.hpp:40

sf::Color::Black
static const Color Black
Black predefined color.
Definition Color.hpp:82

sf::Image::getPixel
Color getPixel(Vector2u coords) const
Get the color of a pixel.

sf::Image::loadFromStream
bool loadFromStream(InputStream &stream)
Load the image from a custom stream.

sf::Image::Image
Image(const std::filesystem::path &filename)
Construct the image from a file on disk.

sf::Image::saveToFile
bool saveToFile(const std::filesystem::path &filename) const
Save the image to a file on disk.

sf::Image::Image
Image(Vector2u size, const std::uint8_t *pixels)
Construct the image from an array of pixels.

sf::Image::copy
bool copy(const Image &source, Vector2u dest, const IntRect &sourceRect={}, bool applyAlpha=false)
Copy pixels from another image onto this one.

sf::Image::flipHorizontally
void flipHorizontally()
Flip the image horizontally (left <-> right)

sf::Image::saveToMemory
std::optional< std::vector< std::uint8_t > > saveToMemory(std::string_view format) const
Save the image to a buffer in memory.

sf::Image::Image
Image(const void *data, std::size_t size)
Construct the image from a file in memory.

sf::Image::createMaskFromColor
void createMaskFromColor(Color color, std::uint8_t alpha=0)
Create a transparency mask from a specified color-key.

sf::Image::flipVertically
void flipVertically()
Flip the image vertically (top <-> bottom)

sf::Image::getSize
Vector2u getSize() const
Return the size (width and height) of the image.

sf::Image::getPixelsPtr
const std::uint8_t * getPixelsPtr() const
Get a read-only pointer to the array of pixels.

sf::Image::Image
Image()=default
Default constructor.

sf::Image::resize
void resize(Vector2u size, const std::uint8_t *pixels)
Resize the image from an array of pixels.

sf::Image::loadFromMemory
bool loadFromMemory(const void *data, std::size_t size)
Load the image from a file in memory.

sf::Image::Image
Image(Vector2u size, Color color=Color::Black)
Construct the image and fill it with a unique color.

sf::Image::loadFromFile
bool loadFromFile(const std::filesystem::path &filename)
Load the image from a file on disk.

sf::Image::Image
Image(InputStream &stream)
Construct the image from a custom stream.

sf::Image::setPixel
void setPixel(Vector2u coords, Color color)
Change the color of a pixel.

sf::Image::resize
void resize(Vector2u size, Color color=Color::Black)
Resize the image and fill it with a unique color.

sf::InputStream
Abstract class for custom file input streams.
Definition InputStream.hpp:46

sf
Definition AudioResource.hpp:36

sf::Vector2u
Vector2< unsigned int > Vector2u
Definition Vector2.hpp:209

sf::IntRect
Rect< int > IntRect
Definition Rect.hpp:146