std::graphic::image< T, BC > Template-Klassenreferenz

#include <image.hpp>

Öffentliche Typen
using	color_type = std::math::color< T >
using	basic_color = BC
using	self_type = image< T, BC >
using	size_type = std::math::vector2< int >

Öffentliche Methoden
	image ()
	image (std::string name, size_type size)
	image (std::string name, size_type size, stream *str)
	~image ()
void	setpixel (size_type pos, color_type col)
color_type &	getpixel (size_type pos)
color_type *	get ()
color_type &	operator[] (size_type pos)

Öffentliche Attribute
std::prop_t< std::string >	Name

Geschützte Methoden
void	create (size_type size, color_type color)

Ausführliche Beschreibung

template<typename T, std::math::color< T > BC = std::math::colors_base<T>::Navy>
class std::graphic::image< T, BC >

Dokumentation der benutzerdefinierten Datentypen

basic_color

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

using std::graphic::image< T, BC >::basic_color = BC

color_type

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

using std::graphic::image< T, BC >::color_type = std::math::color<T>

self_type

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

using std::graphic::image< T, BC >::self_type = image<T, BC>

size_type

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

using std::graphic::image< T, BC >::size_type = std::math::vector2<int>

Beschreibung der Konstruktoren und Destruktoren

image() [1/3]

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

std::graphic::image< T, BC >::image ( )

inline

                     {
                create(size_type(32,32), BC);
            }

image() [2/3]

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

std::graphic::image< T, BC >::image ( std::string  name, size_type  size  )

inline

                                                  {
               create(size, BC);
               Name = name;
            }

image() [3/3]

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

std::graphic::image< T, BC >::image ( std::string  name, size_type  size, stream *  str  )

inline

                                                               {
                Name = name;
                create(size, BC);
                auto x = std::_min<int>( (m_vecSize.x * m_vecSize.y *4),
                        str->size() );
                unsigned char colorBlock[4];
                for (int i = 0; i < x; i++) {
                    
                    if (str->read(colorBlock, 0, 4) == 4)
            m_imgData[i] = color_type(  colorBlock[0], 
                                                    colorBlock[1], 
                                                    colorBlock[2],
                                                    colorBlock[3]);
        }   
            }

~image()

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

std::graphic::image< T, BC >::~image ( )

inline

                     {
                if(m_imgData) { delete m_imgData; }
            }

Dokumentation der Elementfunktionen

create()

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

void std::graphic::image< T, BC >::create ( size_type  size, color_type  color  )

inlineprotected

                                                           {
               m_imgData = new color_type[size.x * size.y]; 
               #pragma openmp
               for(int i = 0; i < size.x * size.y; i++) {
                   m_imgData[i] = basic_color;
               }  
            }

get()

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

color_type* std::graphic::image< T, BC >::get ( )

inline

                              {
                return m_imgData;
            }

getpixel()

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

color_type& std::graphic::image< T, BC >::getpixel ( size_type  pos )

inline

                                                {
                if(pos.x < m_vecSize.x && pos.y < m_vecSize.y ) {
                    return m_imgData[ pos.x + pos.y * m_vecSize.x];
                }
            }

operator[]()

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

color_type& std::graphic::image< T, BC >::operator[] ( size_type  pos )

inline

                                                   {
                 return getpixel(pos);
            }

setpixel()

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

void std::graphic::image< T, BC >::setpixel ( size_type  pos, color_type  col  )

inline

                                                          {
                if(pos.x < m_vecSize.x && pos.y < m_vecSize.y ) {
                    m_imgData[ pos.x + pos.y * m_vecSize.x] = col;
                } 
            }

Dokumentation der Datenelemente

Name

template<typename T , std::math::color< T > BC = std::math::colors_base<T>::Navy>

std::prop_t<std::string> std::graphic::image< T, BC >::Name

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/graphic/image.hpp