From ea318d1431c89e647598c510c4245c6571aa5f46 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Thu, 26 Jan 2012 23:32:43 -0600 Subject: Update to latest tqt3 automated conversion --- doc/html/qimage.html | 1117 -------------------------------------------------- 1 file changed, 1117 deletions(-) delete mode 100644 doc/html/qimage.html (limited to 'doc/html/qimage.html') diff --git a/doc/html/qimage.html b/doc/html/qimage.html deleted file mode 100644 index 1624d7a3c..000000000 --- a/doc/html/qimage.html +++ /dev/null @@ -1,1117 +0,0 @@ - - - - - -TQImage Class - - - - - - - -
- -Home - | -All Classes - | -Main Classes - | -Annotated - | -Grouped Classes - | -Functions -

TQImage Class Reference

- -

The TQImage class provides a hardware-independent pixmap -representation with direct access to the pixel data. -More... -

#include <qimage.h> -

List of all member functions. -

Public Members

- -

Static Public Members

- -

Related Functions

- -

Detailed Description

- - -The TQImage class provides a hardware-independent pixmap -representation with direct access to the pixel data. -

- - - -

It is one of the two classes TQt provides for dealing with images, -the other being TQPixmap. TQImage is designed and optimized for I/O -and for direct pixel access/manipulation. TQPixmap is designed and -optimized for drawing. There are (slow) functions to convert -between TQImage and TQPixmap: TQPixmap::convertToImage() and -TQPixmap::convertFromImage(). -

An image has the parameters width, height and depth (bits per -pixel, bpp), a color table and the actual pixels. TQImage supports 1-bpp, 8-bpp and 32-bpp image -data. 1-bpp and 8-bpp images use a color lookup table; the pixel -value is a color table index. -

32-bpp images encode an RGB value in 24 bits and ignore the color -table. The most significant byte is used for the alpha buffer. -

An entry in the color table is an RGB triplet encoded as a uint. Use the qRed(), qGreen() and qBlue() functions (qcolor.h) to access the components, and qRgb to make an RGB triplet (see the TQColor class -documentation). -

1-bpp (monochrome) images have a color table with a most two -colors. There are two different formats: big endian (MSB first) or -little endian (LSB first) bit order. To access a single bit you -will must do some bit shifts: -

-    TQImage image;
-    // sets bit at (x,y) to 1
-    if ( image.bitOrder() == TQImage::LittleEndian )
-        *(image.scanLine(y) + (x >> 3)) |= 1 << (x & 7);
-    else
-        *(image.scanLine(y) + (x >> 3)) |= 1 << (7 - (x & 7));
-
- -

If this looks complicated, it might be a good idea to convert the -1-bpp image to an 8-bpp image using convertDepth(). -

8-bpp images are much easier to work with than 1-bpp images -because they have a single byte per pixel: -

-    TQImage image;
-    // set entry 19 in the color table to yellow
-    image.setColor( 19, qRgb(255,255,0) );
-    // set 8 bit pixel at (x,y) to value yellow (in color table)
-    *(image.scanLine(y) + x) = 19;
-
- -

32-bpp images ignore the color table; instead, each pixel contains -the RGB triplet. 24 bits contain the RGB value; the most -significant byte is reserved for the alpha buffer. -

-    TQImage image;
-    // sets 32 bit pixel at (x,y) to yellow.
-    uint *p = (uint *)image.scanLine(y) + x;
-    *p = qRgb(255,255,0);
-
- -

On TQt/Embedded, scanlines are aligned to the pixel depth and may -be padded to any degree, while on all other platforms, the -scanlines are 32-bit aligned for all depths. The constructor -taking a uchar* argument always expects 32-bit aligned data. -On TQt/Embedded, an additional constructor allows the number of -bytes-per-line to be specified. -

TQImage supports a variety of methods for getting information about -the image, for example, colorTable(), allGray(), isGrayscale(), -bitOrder(), bytesPerLine(), depth(), dotsPerMeterX() and -dotsPerMeterY(), hasAlphaBuffer(), numBytes(), numColors(), and -width() and height(). -

Pixel colors are retrieved with pixel() and set with setPixel(). -

TQImage also supports a number of functions for creating a new -image that is a transformed version of the original. For example, -copy(), convertBitOrder(), convertDepth(), createAlphaMask(), -createHeuristicMask(), mirror(), scale(), smoothScale(), swapRGB() -and xForm(). There are also functions for changing attributes of -an image in-place, for example, setAlphaBuffer(), setColor(), -setDotsPerMeterX() and setDotsPerMeterY() and setNumColors(). -

Images can be loaded and saved in the supported formats. Images -are saved to a file with save(). Images are loaded from a file -with load() (or in the constructor) or from an array of data with -loadFromData(). The lists of supported formats are available from -inputFormatList() and outputFormatList(). -

Strings of text may be added to images using setText(). -

The TQImage class uses explicit sharing, -similar to that used by TQMemArray. -

New image formats can be added as plugins. -

See also TQImageIO, TQPixmap, Shared Classes, Graphics Classes, Image Processing Classes, and Implicitly and Explicitly Shared Classes. - -

Member Type Documentation

-

TQImage::Endian

- -

This enum type is used to describe the endianness of the CPU and -graphics hardware. -

-

TQImage::ScaleMode

- -

The functions scale() and smoothScale() use different modes for -scaling the image. The purpose of these modes is to retain the -ratio of the image if this is required. -

- -

Member Function Documentation

-

TQImage::TQImage () -

-Constructs a null image. -

See also isNull(). - -

TQImage::TQImage ( int w, int h, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) -

-Constructs an image with w width, h height, depth bits -per pixel, numColors colors and bit order bitOrder. -

Using this constructor is the same as first constructing a null -image and then calling the create() function. -

See also create(). - -

TQImage::TQImage ( const TQSize & size, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) -

-Constructs an image with size size pixels, depth depth bits, -numColors and bitOrder endianness. -

Using this constructor is the same as first constructing a null -image and then calling the create() function. -

See also create(). - -

TQImage::TQImage ( const TQString & fileName, const char * format = 0 ) -

-Constructs an image and tries to load the image from the file fileName. -

If format is specified, the loader attempts to read the image -using the specified format. If format is not specified (which -is the default), the loader reads a few bytes from the header to -guess the file format. -

If the loading of the image failed, this object is a null image. -

The TQImageIO documentation lists the supported image formats and -explains how to add extra formats. -

See also load(), isNull(), and TQImageIO. - -

TQImage::TQImage ( const char * const xpm[] ) -

-Constructs an image from xpm, which must be a valid XPM image. -

Errors are silently ignored. -

Note that it's possible to squeeze the XPM variable a little bit -by using an unusual declaration: -

-        static const char * const start_xpm[]={
-            "16 15 8 1",
-            "a c #cec6bd",
-        ....
-
- -

The extra const makes the entire definition read-only, which is -slightly more efficient (e.g. when the code is in a shared -library) and ROMable when the application is to be stored in ROM. - -

TQImage::TQImage ( const TQByteArray & array ) -

-Constructs an image from the binary data array. It tries to -guess the file format. -

If the loading of the image failed, this object is a null image. -

See also loadFromData(), isNull(), and imageFormat(). - -

TQImage::TQImage ( uchar * yourdata, int w, int h, int depth, TQRgb * colortable, int numColors, Endian bitOrder ) -

-Constructs an image w pixels wide, h pixels high with a -color depth of depth, that uses an existing memory buffer, yourdata. The buffer must remain valid throughout the life of the -TQImage. The image does not delete the buffer at destruction. -

If colortable is 0, a color table sufficient for numColors -will be allocated (and destructed later). -

Note that yourdata must be 32-bit aligned. -

The endianness is given in bitOrder. - -

TQImage::TQImage ( uchar * yourdata, int w, int h, int depth, int bpl, TQRgb * colortable, int numColors, Endian bitOrder ) -

-Constructs an image that uses an existing memory buffer. The -buffer must remain valid for the life of the TQImage. The image -does not delete the buffer at destruction. The buffer is passed as -yourdata. The image's width is w and its height is h. The -color depth is depth. bpl specifies the number of bytes per -line. -

If colortable is 0, a color table sufficient for numColors -will be allocated (and destructed later). -

The endianness is specified by bitOrder. -

Warning: This constructor is only available on TQt/Embedded. - -

TQImage::TQImage ( const TQImage & image ) -

-Constructs a shallow copy of image. - -

TQImage::~TQImage () -

-Destroys the image and cleans up. - -

bool TQImage::allGray () const -

-Returns TRUE if all the colors in the image are shades of gray -(i.e. their red, green and blue components are equal); otherwise -returns FALSE. -

This function is slow for large 16-bit (TQt/Embedded only) and 32-bit images. -

See also isGrayscale(). - -

Endian TQImage::bitOrder () const -

- -

Returns the bit order for the image. -

If it is a 1-bpp image, this function returns either -TQImage::BigEndian or TQImage::LittleEndian. -

If it is not a 1-bpp image, this function returns -TQImage::IgnoreEndian. -

See also depth(). - -

uchar * TQImage::bits () const -

- -

Returns a pointer to the first pixel data. This is equivalent to -scanLine(0). -

See also numBytes(), scanLine(), and jumpTable(). - -

Example: opengl/texture/gltexobj.cpp. -

int TQImage::bytesPerLine () const -

- -

Returns the number of bytes per image scanline. This is equivalent -to numBytes()/height(). -

See also numBytes() and scanLine(). - -

TQRgb TQImage::color ( int i ) const -

- -

Returns the color in the color table at index i. The first -color is at index 0. -

A color value is an RGB triplet. Use the qRed(), qGreen() and qBlue() functions (defined in qcolor.h) to -get the color value components. -

See also setColor(), numColors(), and TQColor. - -

Example: themes/wood.cpp. -

TQRgb * TQImage::colorTable () const -

- -

Returns a pointer to the color table. -

See also numColors(). - -

TQImage TQImage::convertBitOrder ( Endian bitOrder ) const -

-Converts the bit order of the image to bitOrder and returns the -converted image. The original image is not changed. -

Returns *this if the bitOrder is equal to the image bit -order, or a null image if this image cannot -be converted. -

See also bitOrder(), systemBitOrder(), and isNull(). - -

TQImage TQImage::convertDepth ( int depth, int conversion_flags ) const -

-Converts the depth (bpp) of the image to depth and returns the -converted image. The original image is not changed. -

The depth argument must be 1, 8, 16 (TQt/Embedded only) or 32. -

Returns *this if depth is equal to the image depth, or a -null image if this image cannot be -converted. -

If the image needs to be modified to fit in a lower-resolution -result (e.g. converting from 32-bit to 8-bit), use the conversion_flags to specify how you'd prefer this to happen. -

See also TQt::ImageConversionFlags, depth(), and isNull(). - -

TQImage TQImage::convertDepth ( int depth ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

-

TQImage TQImage::convertDepthWithPalette ( int d, TQRgb * palette, int palette_count, int conversion_flags = 0 ) const -

-Returns an image with depth d, using the palette_count -colors pointed to by palette. If d is 1 or 8, the returned -image will have its color table ordered the same as palette. -

If the image needs to be modified to fit in a lower-resolution -result (e.g. converting from 32-bit to 8-bit), use the conversion_flags to specify how you'd prefer this to happen. -

Note: currently no closest-color search is made. If colors are -found that are not in the palette, the palette may not be used at -all. This result should not be considered valid because it may -change in future implementations. -

Currently inefficient for non-32-bit images. -

See also TQt::ImageConversionFlags. - -

TQImage TQImage::copy () const -

-Returns a deep copy of the image. -

See also detach(). - -

TQImage TQImage::copy ( int x, int y, int w, int h, int conversion_flags = 0 ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

Returns a deep copy of a sub-area of -the image. -

The returned image is always w by h pixels in size, and is -copied from position x, y in this image. In areas beyond -this image pixels are filled with pixel 0. -

If the image needs to be modified to fit in a lower-resolution -result (e.g. converting from 32-bit to 8-bit), use the conversion_flags to specify how you'd prefer this to happen. -

See also bitBlt() and TQt::ImageConversionFlags. - -

TQImage TQImage::copy ( const TQRect & r ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

Returns a deep copy of a sub-area of -the image. -

The returned image always has the size of the rectangle r. In -areas beyond this image pixels are filled with pixel 0. - -

bool TQImage::create ( int width, int height, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) -

-Sets the image width, height, depth, its number of colors -(in numColors), and bit order. Returns TRUE if successful, or -FALSE if the parameters are incorrect or if memory cannot be -allocated. -

The width and height is limited to 32767. depth must be -1, 8, or 32. If depth is 1, bitOrder must be set to -either TQImage::LittleEndian or TQImage::BigEndian. For other depths -bitOrder must be TQImage::IgnoreEndian. -

This function allocates a color table and a buffer for the image -data. The image data is not initialized. -

The image buffer is allocated as a single block that consists of a -table of scanline pointers (jumpTable()) -and the image data (bits()). -

See also fill(), width(), height(), depth(), numColors(), bitOrder(), jumpTable(), scanLine(), bits(), bytesPerLine(), and numBytes(). - -

bool TQImage::create ( const TQSize &, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

-

TQImage TQImage::createAlphaMask ( int conversion_flags = 0 ) const -

-Builds and returns a 1-bpp mask from the alpha buffer in this -image. Returns a null image if alpha buffer mode is disabled. -

See TQPixmap::convertFromImage() for a description of the conversion_flags argument. -

The returned image has little-endian bit order, which you can -convert to big-endianness using convertBitOrder(). -

See also createHeuristicMask(), hasAlphaBuffer(), and setAlphaBuffer(). - -

TQImage TQImage::createHeuristicMask ( bool clipTight = TRUE ) const -

-Creates and returns a 1-bpp heuristic mask for this image. It -works by selecting a color from one of the corners, then chipping -away pixels of that color starting at all the edges. -

The four corners vote for which color is to be masked away. In -case of a draw (this generally means that this function is not -applicable to the image), the result is arbitrary. -

The returned image has little-endian bit order, which you can -convert to big-endianness using convertBitOrder(). -

If clipTight is TRUE the mask is just large enough to cover the -pixels; otherwise, the mask is larger than the data pixels. -

This function disregards the alpha buffer. -

See also createAlphaMask(). - -

int TQImage::depth () const -

- -

Returns the depth of the image. -

The image depth is the number of bits used to encode a single -pixel, also called bits per pixel (bpp) or bit planes of an image. -

The supported depths are 1, 8, 16 (TQt/Embedded only) and 32. -

See also convertDepth(). - -

void TQImage::detach () -

-Detaches from shared image data and makes sure that this image is -the only one referring to the data. -

If multiple images share common data, this image makes a copy of -the data and detaches itself from the sharing mechanism. -Nothing is done if there is just a single reference. -

See also copy(). - -

Example: themes/wood.cpp. -

int TQImage::dotsPerMeterX () const -

- -

Returns the number of pixels that fit horizontally in a physical -meter. This and dotsPerMeterY() define the intended scale and -aspect ratio of the image. -

See also setDotsPerMeterX(). - -

int TQImage::dotsPerMeterY () const -

- -

Returns the number of pixels that fit vertically in a physical -meter. This and dotsPerMeterX() define the intended scale and -aspect ratio of the image. -

See also setDotsPerMeterY(). - -

void TQImage::fill ( uint pixel ) -

-Fills the entire image with the pixel value pixel. -

If the depth of this image is 1, only the -lowest bit is used. If you say fill(0), fill(2), etc., the image -is filled with 0s. If you say fill(1), fill(3), etc., the image is -filled with 1s. If the depth is 8, the lowest 8 bits are used. -

If the depth is 32 and the image has no alpha buffer, the pixel -value is written to each pixel in the image. If the image has an -alpha buffer, only the 24 RGB bits are set and the upper 8 bits -(alpha value) are left unchanged. -

Note: TQImage::pixel() returns the color of the pixel at the given -coordinates; TQColor::pixel() returns the pixel value of the -underlying window system (essentially an index value), so normally -you will want to use TQImage::pixel() to use a color from an -existing image or TQColor::rgb() to use a specific color. -

See also invertPixels(), depth(), hasAlphaBuffer(), and create(). - -

TQImage TQImage::fromMimeSource ( const TQString & abs_name ) [static] -

Convenience function. Gets the data associated with the absolute -name abs_name from the default mime source factory and decodes it -to an image. -

See also TQMimeSourceFactory, TQImage::fromMimeSource(), and TQImageDrag::decode(). - -

bool TQImage::hasAlphaBuffer () const -

- -

Returns TRUE if alpha buffer mode is enabled; otherwise returns -FALSE. -

See also setAlphaBuffer(). - -

int TQImage::height () const -

- -

Returns the height of the image. -

See also width(), size(), and rect(). - -

Examples: canvas/canvas.cpp and opengl/texture/gltexobj.cpp. -

const char * TQImage::imageFormat ( const TQString & fileName ) [static] -

-Returns a string that specifies the image format of the file fileName, or 0 if the file cannot be read or if the format is not -recognized. -

The TQImageIO documentation lists the guaranteed supported image -formats, or use TQImage::inputFormats() and TQImage::outputFormats() -to get lists that include the installed formats. -

See also load() and save(). - -

TQStringList TQImage::inputFormatList () [static] -

-Returns a list of image formats that are supported for image -input. -

Note that if you want to iterate over the list, you should iterate -over a copy, e.g. -

-    TQStringList list = myImage.inputFormatList();
-    TQStringList::Iterator it = list.begin();
-    while( it != list.end() ) {
-        myProcessing( *it );
-        ++it;
-    }
-
- -

See also outputFormatList(), inputFormats(), and TQImageIO. - -

Example: showimg/showimg.cpp. -

TQStrList TQImage::inputFormats () [static] -

-Returns a list of image formats that are supported for image -input. -

See also outputFormats(), inputFormatList(), and TQImageIO. - -

void TQImage::invertPixels ( bool invertAlpha = TRUE ) -

-Inverts all pixel values in the image. -

If the depth is 32: if invertAlpha is TRUE, the alpha bits are -also inverted, otherwise they are left unchanged. -

If the depth is not 32, the argument invertAlpha has no -meaning. -

Note that inverting an 8-bit image means to replace all pixels -using color index i with a pixel using color index 255 minus i. Similarly for a 1-bit image. The color table is not changed. -

See also fill(), depth(), and hasAlphaBuffer(). - -

bool TQImage::isGrayscale () const -

-For 16-bit (TQt/Embedded only) and 32-bit images, this function is -equivalent to allGray(). -

For 8-bpp images, this function returns TRUE if color(i) is -TQRgb(i,i,i) for all indices of the color table; otherwise returns -FALSE. -

See also allGray() and depth(). - -

bool TQImage::isNull () const -

- -

Returns TRUE if it is a null image; otherwise returns FALSE. -

A null image has all parameters set to zero and no allocated data. - -

Example: showimg/showimg.cpp. -

uchar ** TQImage::jumpTable () const -

- -

Returns a pointer to the scanline pointer table. -

This is the beginning of the data block for the image. -

See also bits() and scanLine(). - -

bool TQImage::load ( const TQString & fileName, const char * format = 0 ) -

-Loads an image from the file fileName. Returns TRUE if the -image was successfully loaded; otherwise returns FALSE. -

If format is specified, the loader attempts to read the image -using the specified format. If format is not specified (which -is the default), the loader reads a few bytes from the header to -guess the file format. -

The TQImageIO documentation lists the supported image formats and -explains how to add extra formats. -

See also loadFromData(), save(), imageFormat(), TQPixmap::load(), and TQImageIO. - -

bool TQImage::loadFromData ( const uchar * buf, uint len, const char * format = 0 ) -

-Loads an image from the first len bytes of binary data in buf. Returns TRUE if the image was successfully loaded; otherwise -returns FALSE. -

If format is specified, the loader attempts to read the image -using the specified format. If format is not specified (which -is the default), the loader reads a few bytes from the header to -guess the file format. -

The TQImageIO documentation lists the supported image formats and -explains how to add extra formats. -

See also load(), save(), imageFormat(), TQPixmap::loadFromData(), and TQImageIO. - -

bool TQImage::loadFromData ( TQByteArray buf, const char * format = 0 ) -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

Loads an image from the TQByteArray buf. - -

TQImage TQImage::mirror () const -

-Returns a TQImage which is a vertically mirrored copy of this -image. The original TQImage is not changed. - -

TQImage TQImage::mirror ( bool horizontal, bool vertical ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

Returns a mirror of the image, mirrored in the horizontal and/or -the vertical direction depending on whether horizontal and vertical are set to TRUE or FALSE. The original image is not -changed. -

See also smoothScale(). - -

int TQImage::numBytes () const -

- -

Returns the number of bytes occupied by the image data. -

See also bytesPerLine() and bits(). - -

int TQImage::numColors () const -

- -

Returns the size of the color table for the image. -

Notice that numColors() returns 0 for 16-bpp (TQt/Embedded only) -and 32-bpp images because these images do not use color tables, -but instead encode pixel values as RGB triplets. -

See also setNumColors() and colorTable(). - -

Example: themes/wood.cpp. -

TQPoint TQImage::offset () const -

- -

Returns the number of pixels by which the image is intended to be -offset by when positioning relative to other images. - -

bool TQImage::operator!= ( const TQImage & i ) const -

-Returns TRUE if this image and image i have different contents; -otherwise returns FALSE. The comparison can be slow, unless there -is some obvious difference, such as different widths, in which -case the function will return tquickly. -

See also operator=(). - -

TQImage & TQImage::operator= ( const TQImage & image ) -

-Assigns a shallow copy of image to -this image and returns a reference to this image. -

See also copy(). - -

TQImage & TQImage::operator= ( const TQPixmap & pixmap ) -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

Sets the image bits to the pixmap contents and returns a -reference to the image. -

If the image shares data with other images, it will first -dereference the shared data. -

Makes a call to TQPixmap::convertToImage(). - -

bool TQImage::operator== ( const TQImage & i ) const -

-Returns TRUE if this image and image i have the same contents; -otherwise returns FALSE. The comparison can be slow, unless there -is some obvious difference, such as different widths, in which -case the function will return tquickly. -

See also operator=(). - -

TQStringList TQImage::outputFormatList () [static] -

-Returns a list of image formats that are supported for image -output. -

Note that if you want to iterate over the list, you should iterate -over a copy, e.g. -

-    TQStringList list = myImage.outputFormatList();
-    TQStringList::Iterator it = list.begin();
-    while( it != list.end() ) {
-        myProcessing( *it );
-        ++it;
-    }
-
- -

See also inputFormatList(), outputFormats(), and TQImageIO. - -

TQStrList TQImage::outputFormats () [static] -

-Returns a list of image formats that are supported for image -output. -

See also inputFormats(), outputFormatList(), and TQImageIO. - -

Example: showimg/showimg.cpp. -

TQRgb TQImage::pixel ( int x, int y ) const -

-Returns the color of the pixel at the coordinates (x, y). -

If (x, y) is not on the image, the -results are undefined. -

See also setPixel(), qRed(), qGreen(), qBlue(), and valid(). - -

Examples: canvas/canvas.cpp and qmag/qmag.cpp. -

int TQImage::pixelIndex ( int x, int y ) const -

-Returns the pixel index at the given coordinates. -

If (x, y) is not valid, or if the -image is not a paletted image (depth() > 8), the results are -undefined. -

See also valid() and depth(). - -

TQRect TQImage::rect () const -

- -

Returns the enclosing rectangle (0, 0, width(), height()) of the -image. -

See also width(), height(), and size(). - -

void TQImage::reset () -

-Resets all image parameters and deallocates the image data. - -

bool TQImage::save ( const TQString & fileName, const char * format, int quality = -1 ) const -

-Saves the image to the file fileName, using the image file -format format and a quality factor of quality. quality -must be in the range 0..100 or -1. Specify 0 to obtain small -compressed files, 100 for large uncompressed files, and -1 (the -default) to use the default settings. -

Returns TRUE if the image was successfully saved; otherwise -returns FALSE. -

See also load(), loadFromData(), imageFormat(), TQPixmap::save(), and TQImageIO. - -

bool TQImage::save ( TQIODevice * device, const char * format, int quality = -1 ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

This function writes a TQImage to the TQIODevice, device. This -can be used, for example, to save an image directly into a -TQByteArray: -

-    TQImage image;
-    TQByteArray ba;
-    TQBuffer buffer( ba );
-    buffer.open( IO_WriteOnly );
-    image.save( &buffer, "PNG" ); // writes image into ba in PNG format
-
- - -

TQImage TQImage::scale ( int w, int h, ScaleMode mode = ScaleFree ) const -

-Returns a copy of the image scaled to a rectangle of width w -and height h according to the ScaleMode mode. -

-

If either the width w or the height h is 0 or negative, this -function returns a null image. -

This function uses a simple, fast algorithm. If you need better -quality, use smoothScale() instead. -

See also scaleWidth(), scaleHeight(), smoothScale(), and xForm(). - -

TQImage TQImage::scale ( const TQSize & s, ScaleMode mode = ScaleFree ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

The requested size of the image is s. - -

TQImage TQImage::scaleHeight ( int h ) const -

-Returns a scaled copy of the image. The returned image has a -height of h pixels. This function automatically calculates the -width of the image so that the ratio of the image is preserved. -

If h is 0 or negative a null image is -returned. -

See also scale(), scaleWidth(), smoothScale(), and xForm(). - -

Example: table/small-table-demo/main.cpp. -

TQImage TQImage::scaleWidth ( int w ) const -

-Returns a scaled copy of the image. The returned image has a width -of w pixels. This function automatically calculates the height -of the image so that the ratio of the image is preserved. -

If w is 0 or negative a null image is -returned. -

See also scale(), scaleHeight(), smoothScale(), and xForm(). - -

uchar * TQImage::scanLine ( int i ) const -

- -

Returns a pointer to the pixel data at the scanline with index i. The first scanline is at index 0. -

The scanline data is aligned on a 32-bit boundary. -

Warning: If you are accessing 32-bpp image data, cast the returned -pointer to TQRgb* (TQRgb has a 32-bit size) and use it to -read/write the pixel value. You cannot use the uchar* pointer -directly, because the pixel format depends on the byte order on -the underlying platform. Hint: use qRed(), -qGreen() and qBlue(), etc. (qcolor.h) to access the pixels. -

Warning: If you are accessing 16-bpp image data, you must handle -endianness yourself. (TQt/Embedded only) -

See also bytesPerLine(), bits(), and jumpTable(). - -

Example: desktop/desktop.cpp. -

void TQImage::setAlphaBuffer ( bool enable ) -

-Enables alpha buffer mode if enable is TRUE, otherwise disables -it. The default setting is disabled. -

An 8-bpp image has 8-bit pixels. A pixel is an index into the -color table, which contains 32-bit color -values. In a 32-bpp image, the 32-bit pixels are the color values. -

This 32-bit value is encoded as follows: The lower 24 bits are -used for the red, green, and blue components. The upper 8 bits -contain the alpha component. -

The alpha component specifies the transparency of a pixel. 0 means -completely transparent and 255 means opaque. The alpha component -is ignored if you do not enable alpha buffer mode. -

The alpha buffer is used to set a mask when a TQImage is translated -to a TQPixmap. -

See also hasAlphaBuffer() and createAlphaMask(). - -

void TQImage::setColor ( int i, TQRgb c ) -

- -

Sets a color in the color table at index i to c. -

A color value is an RGB triplet. Use the qRgb() function (defined in qcolor.h) to make RGB -triplets. -

See also color(), setNumColors(), and numColors(). - -

Examples: desktop/desktop.cpp and themes/wood.cpp. -

void TQImage::setDotsPerMeterX ( int x ) -

-Sets the value returned by dotsPerMeterX() to x. - -

void TQImage::setDotsPerMeterY ( int y ) -

-Sets the value returned by dotsPerMeterY() to y. - -

void TQImage::setNumColors ( int numColors ) -

-Resizes the color table to numColors colors. -

If the color table is expanded all the extra colors will be set to -black (RGB 0,0,0). -

See also numColors(), color(), setColor(), and colorTable(). - -

void TQImage::setOffset ( const TQPoint & p ) -

-Sets the value returned by offset() to p. - -

void TQImage::setPixel ( int x, int y, uint index_or_rgb ) -

-Sets the pixel index or color at the coordinates (x, y) to -index_or_rgb. -

If (x, y) is not valid, the result is -undefined. -

If the image is a paletted image (depth() <= 8) and index_or_rgb >= numColors(), the result is undefined. -

See also pixelIndex(), pixel(), qRgb(), qRgba(), and valid(). - -

void TQImage::setText ( const char * key, const char * lang, const TQString & s ) -

-Records string s for the keyword key. The key should be a -portable keyword recognizable by other software - some suggested -values can be found in the PNG specification. s can be any text. lang -should specify the language code (see -RFC 1766) or 0. - -

TQSize TQImage::size () const -

- -

Returns the size of the image, i.e. its width and height. -

See also width(), height(), and rect(). - -

TQImage TQImage::smoothScale ( int w, int h, ScaleMode mode = ScaleFree ) const -

-Returns a smoothly scaled copy of the image. The returned image -has a size of width w by height h pixels if mode is ScaleFree. The modes ScaleMin and ScaleMax may be used to -preserve the ratio of the image: if mode is ScaleMin, the -returned image is guaranteed to fit into the rectangle specified -by w and h (it is as large as possible within the -constraints); if mode is ScaleMax, the returned image fits -at least into the specified rectangle (it is a small as possible -within the constraints). -

For 32-bpp images and 1-bpp/8-bpp color images the result will be -32-bpp, whereas all-gray images -(including black-and-white 1-bpp) will produce 8-bit grayscale images with the palette spanning -256 grays from black to white. -

This function uses code based on pnmscale.c by Jef Poskanzer. -

pnmscale.c - read a portable anymap and scale it -

-

Copyright (C) 1989, 1991 by Jef Poskanzer. -

Permission to use, copy, modify, and distribute this software and -its documentation for any purpose and without fee is hereby -granted, provided that the above copyright notice appear in all -copies and that both that copyright notice and this permission -notice appear in supporting documentation. This software is -provided "as is" without express or implied warranty. -

See also scale() and mirror(). - -

TQImage TQImage::smoothScale ( const TQSize & s, ScaleMode mode = ScaleFree ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

The requested size of the image is s. - -

TQImage TQImage::swapRGB () const -

-Returns a TQImage in which the values of the red and blue -components of all pixels have been swapped, effectively converting -an RGB image to a BGR image. The original TQImage is not changed. - -

Endian TQImage::systemBitOrder () [static] -

-Determines the bit order of the display hardware. Returns -TQImage::LittleEndian (LSB first) or TQImage::BigEndian (MSB first). -

See also systemByteOrder(). - -

Endian TQImage::systemByteOrder () [static] -

-Determines the host computer byte order. Returns -TQImage::LittleEndian (LSB first) or TQImage::BigEndian (MSB first). -

See also systemBitOrder(). - -

TQString TQImage::text ( const char * key, const char * lang = 0 ) const -

-Returns the string recorded for the keyword key in language lang, or in a default language if lang is 0. - -

TQString TQImage::text ( const TQImageTextKeyLang & kl ) const -

-This is an overloaded member function, provided for convenience. It behaves essentially like the above function. -

Returns the string recorded for the keyword and language kl. - -

TQStringList TQImage::textKeys () const -

-Returns the keywords for which some texts are recorded. -

Note that if you want to iterate over the list, you should iterate -over a copy, e.g. -

-    TQStringList list = myImage.textKeys();
-    TQStringList::Iterator it = list.begin();
-    while( it != list.end() ) {
-        myProcessing( *it );
-        ++it;
-    }
-
- -

See also textList(), text(), setText(), and textLanguages(). - -

TQStringList TQImage::textLanguages () const -

-Returns the language identifiers for which some texts are -recorded. -

Note that if you want to iterate over the list, you should iterate -over a copy, e.g. -

-    TQStringList list = myImage.textLanguages();
-    TQStringList::Iterator it = list.begin();
-    while( it != list.end() ) {
-        myProcessing( *it );
-        ++it;
-    }
-
- -

See also textList(), text(), setText(), and textKeys(). - -

TQValueList<TQImageTextKeyLang> TQImage::textList () const -

-Returns a list of TQImageTextKeyLang objects that enumerate all the -texts key/language pairs set by setText() for this image. -

Note that if you want to iterate over the list, you should iterate -over a copy, e.g. -

-    TQValueList<TQImageTextKeyLang> list = myImage.textList();
-    TQValueList<TQImageTextKeyLang>::Iterator it = list.begin();
-    while( it != list.end() ) {
-        myProcessing( *it );
-        ++it;
-    }
-
- - -

bool TQImage::valid ( int x, int y ) const -

-Returns TRUE if ( x, y ) is a valid coordinate in the image; -otherwise returns FALSE. -

See also width(), height(), and pixelIndex(). - -

Examples: canvas/canvas.cpp and qmag/qmag.cpp. -

int TQImage::width () const -

- -

Returns the width of the image. -

See also height(), size(), and rect(). - -

Examples: canvas/canvas.cpp and opengl/texture/gltexobj.cpp. -

TQImage TQImage::xForm ( const TQWMatrix & matrix ) const -

-Returns a copy of the image that is transformed using the -transformation matrix, matrix. -

The transformation matrix is internally adjusted to compensate -for unwanted translation, i.e. xForm() returns the smallest image -that contains all the transformed points of the original image. -

See also scale(), TQPixmap::xForm(), TQPixmap::trueMatrix(), and TQWMatrix. - -

Related Functions

-

void bitBlt ( TQImage * dst, int dx, int dy, const TQImage * src, int sx, int sy, int sw, int sh, int conversion_flags ) -

- -

Copies a block of pixels from src to dst. The pixels -copied from source (src) are converted according to -conversion_flags if it is incompatible with the destination -(dst). -

sx, sy is the top-left pixel in src, dx, dy -is the top-left position in dst and sw, \sh is the -size of the copied block. -

The copying is clipped if areas outside src or dst are -specified. -

If sw is -1, it is adjusted to src->width(). Similarly, if sh is -1, it is adjusted to src->height(). -

Currently inefficient for non 32-bit images. - -

TQDataStream & operator<< ( TQDataStream & s, const TQImage & image ) -

- -

Writes the image image to the stream s as a PNG image, or as a -BMP image if the stream's version is 1. -

Note that writing the stream to a file will not produce a valid image file. -

See also TQImage::save() and Format of the TQDataStream operators. - -

TQDataStream & operator>> ( TQDataStream & s, TQImage & image ) -

- -

Reads an image from the stream s and stores it in image. -

See also TQImage::load() and Format of the TQDataStream operators. - - -

-This file is part of the TQt toolkit. -Copyright © 1995-2007 -Trolltech. All Rights Reserved.

- -
Copyright © 2007 -TrolltechTrademarks -
TQt 3.3.8
-
- -- cgit v1.2.1