image.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef H_OGF_IMAGE_TYPES_IMAGE_H
#define H_OGF_IMAGE_TYPES_IMAGE_H
 
#include <geogram/basic/common.h>
#include <geogram/image/colormap.h>
 
namespace GEO {
 
//_________________________________________________________
 
 
    class GEOGRAM_API Image : public Counted {
    public:
 
        enum ColorEncoding {
            GRAY, INDEXED, RGB, BGR, RGBA, YUV
        };
 
        enum ComponentEncoding {
            BYTE, INT16, INT32, FLOAT32, FLOAT64
        };
 
 
        Image();
 
        Image(
            ColorEncoding color_rep, ComponentEncoding component_rep,
            index_t width, index_t height=1, index_t depth=1
        ) {
            base_mem_ = nullptr;
            initialize(color_rep, component_rep, width, height, depth);
        }
 
        ~Image() override;
 
        virtual void acquire();
 
        index_t dimension() const {
            return dimension_;
        }
 
        index_t size(index_t axis) const {
            geo_assert(axis < 3);
            return size_[axis];
        }
 
        index_t width() const  {
            return size_[0];
        }
 
        index_t height() const  {
            return size_[1];
        }
 
        index_t depth() const  {
            return size_[2];
        }
 
        size_t bytes_per_pixel() const {
            return bytes_per_pixel_;
        }
 
        size_t components_per_pixel() const {
            return nb_components(color_encoding());
        }
 
        size_t nb_pixels() const {
            return size_t(size_[0]) * size_t(size_[1]) * size_t(size_[2]);
        }
 
        size_t bytes() const {
            return nb_pixels() * bytes_per_pixel();
        }
 
        ComponentEncoding component_encoding() const {
            return component_encoding_;
        }
 
        ColorEncoding color_encoding() const {
            return color_encoding_;
        }
 
        const Colormap* colormap() const {
            return colormap_;
        }
 
        Colormap* colormap()             {
            return colormap_;
        }
 
        void set_colormap(Colormap* colormap) {
            colormap_ = colormap;
        }
 
        Memory::pointer base_mem() const {
            return base_mem_;
        }
 
        Memory::byte* base_mem_byte_ptr() const {
            return byte_ptr(base_mem_);
        }
 
        Numeric::int16* base_mem_int16_ptr() const {
            return int16_ptr(base_mem_);
        }
 
        Numeric::int32* base_mem_int32_ptr() const {
            return int32_ptr(base_mem_);
        }
 
        Numeric::float32* base_mem_float32_ptr() const {
            return float32_ptr(base_mem_);
        }
 
        Numeric::float64* base_mem_float64_ptr() const {
            return float64_ptr(base_mem_);
        }
 
        Memory::pointer pixel_base(index_t x) {
            return base_mem() + x * factor_[0];
        }
 
 
        Memory::byte* pixel_base_byte_ptr(index_t x) {
            return byte_ptr(base_mem() + x * factor_[0]);
        }
 
        Numeric::int16* pixel_base_int16_ptr(index_t x) {
            return int16_ptr(base_mem() + x * factor_[0]);
        }
 
        Numeric::int32* pixel_base_int32_ptr(index_t x) {
            return int32_ptr(base_mem() + x * factor_[0]);
        }
 
        Numeric::float32* pixel_base_float32_ptr(index_t x) {
            return float32_ptr(base_mem() + x * factor_[0]);
        }
 
        Numeric::float64* pixel_base_float64_ptr(index_t x) {
            return float64_ptr(base_mem() + x * factor_[0]);
        }
 
 
        Memory::pointer pixel_base(index_t x, index_t y) {
            return base_mem() + x * factor_[0] + y * factor_[1];
        }
 
        Memory::byte* pixel_base_byte_ptr(index_t x, index_t y) {
            return byte_ptr(base_mem() + x * factor_[0] + y * factor_[1]);
        }
 
        Numeric::int16* pixel_base_int16_ptr(index_t x, index_t y) {
            return int16_ptr(base_mem() + x * factor_[0] + y * factor_[1]);
        }
 
        Numeric::int32* pixel_base_int32_ptr(index_t x, index_t y) {
            return int32_ptr(base_mem() + x * factor_[0] + y * factor_[1]);
        }
 
        Numeric::float32* pixel_base_float32_ptr(index_t x, index_t y) {
            return float32_ptr(base_mem() + x * factor_[0] + y * factor_[1]);
        }
 
        Numeric::float64* pixel_base_float64_ptr(index_t x, index_t y) {
            return float64_ptr(base_mem() + x * factor_[0] + y * factor_[1]);
        }
 
        Memory::pointer pixel_base(index_t x, index_t y, index_t z) {
            return base_mem() +
                x * factor_[0] + y * factor_[1] + z * factor_[2];
        }
 
        Memory::byte* pixel_base_byte_ptr(index_t x, index_t y, index_t z) {
            return byte_ptr(base_mem() +
                            x * factor_[0] + y * factor_[1] + z * factor_[2]
                           );
        }
 
        Numeric::int16* pixel_base_int16_ptr(index_t x, index_t y, index_t z) {
            return int16_ptr(base_mem() +
                             x * factor_[0] + y * factor_[1] + z * factor_[2]
                            );
        }
 
        Numeric::int32* pixel_base_int32_ptr(index_t x, index_t y, index_t z) {
            return int32_ptr(base_mem() +
                             x * factor_[0] + y * factor_[1] + z * factor_[2]
                            );
        }
 
        Numeric::float32* pixel_base_float32_ptr(
            index_t x, index_t y, index_t z
        ) {
            return float32_ptr(base_mem() +
                               x * factor_[0] + y * factor_[1] + z * factor_[2]
                              );
        }
 
        Numeric::float64* pixel_base_float64_ptr(
            index_t x, index_t y, index_t z
        ) {
            return float64_ptr(base_mem() +
                               x * factor_[0] + y * factor_[1] + z * factor_[2]
                              );
        }
 
        static size_t nb_components(ColorEncoding color_rep);
 
        static size_t bytes_per_component(ComponentEncoding component_rep);
 
        Memory::byte* byte_ptr(Memory::pointer ptr) const {
            geo_debug_assert(component_encoding_ == BYTE);
            return ptr;
        }
 
        Numeric::int16* int16_ptr(Memory::pointer ptr) const {
            geo_debug_assert(component_encoding_ == INT16);
            return (Numeric::int16*)(void*)(ptr);
        }
 
        Numeric::int32* int32_ptr(Memory::pointer ptr) const {
            geo_debug_assert(component_encoding_ == INT32);
            return (Numeric::int32*)(void*)(ptr);
        }
 
        Numeric::float32* float32_ptr(Memory::pointer ptr) const {
            geo_debug_assert(component_encoding_ == FLOAT32);
            return (Numeric::float32*)(void*)(ptr);
        }
 
        Numeric::float64* float64_ptr(Memory::pointer ptr) const {
            geo_debug_assert(component_encoding_ == FLOAT64);
            return (Numeric::float64*)(void*)(ptr);
        }
 
        void flip_vertically();
 
        void swap_components(index_t channel1, index_t channel2);
 
        void initialize(
            ColorEncoding color_rep, ComponentEncoding component_rep,
            index_t size_x, index_t size_y=1, index_t size_z=1
        );
 
    protected:
        ColorEncoding color_encoding_;
        ComponentEncoding component_encoding_;
        Colormap_var colormap_;
        size_t factor_[3];
        Memory::pointer base_mem_;
        index_t dimension_;
        index_t size_[3];
        size_t bytes_per_pixel_;
 
    private:
        Image(const Image& rhs);
 
        Image& operator=(const Image& rhs);
    };
 
    typedef SmartPointer<Image> Image_var;
 
//_________________________________________________________
 
}
#endif