1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
\section{Magick::Pixels}
\scriptsize{
\begin{verbatim}
The Pixels class provides efficient access to raw image pixels. Image pixels
(of type PixelPacket) may be accessed directly via the Image Pixel Cache.
The image pixel cache is a rectangular window (a view) into the actual image
pixels (which may be in memory, memory-mapped from a disk file, or entirely
on disk). Obtain existing image pixels via get(). Create a new pixel region
using set().
Depending on the capabilities of the operating system, and the relationship
of the window to the image, the pixel cache may be a copy of the pixels in
the selected window, or it may be the actual image pixels. In any case
calling sync() insures that the base image is updated with the contents of
the modified pixel cache. The method decode() supports copying foreign pixel
data formats into the pixel cache according to the QuantumTypes. The method
encode() supports copying the pixels in the cache to a foreign pixel
representation according to the format specified by QuantumTypes.
Setting a view using the Pixels class does not cause the number of
references to the underlying image to be reduced to one. Therefore, in order
to ensure that only the current generation of the image is modified, the
Image's modifyImage() method should be invoked to reduce the reference count
on the underlying image to one. If this is not done, then it is possible for
a previous generation of the image to be modified due to the use of
reference counting when copying or constructing an Image.
The PixelPacket* returned by the set and get methods, and the IndexPacket*
returned by the indexes method point to pixel data managed by the Pixels
class. The Pixels class is responsible for releasing resources associated
with the pixel view. This means that the pointer should never be passed to
delete() or free().
The pixel view is a small image in which the pixels may be accessed,
addressed, and updated, as shown in the following example, which produces an
image similar to the one on the right (minus lines and text):
// Create base image
Image image(Geometry(254,218), "white");
// Set image pixels to DirectClass representation
image.classType( DirectClass );
// Ensure that there is only one reference to underlying
image
image.modifyImage();
// Allocate pixel view
Pixels view(image);
// Set all pixels in region anchored at 38x36, with size
160x230 to green.
unsigned int columns = 196; unsigned int rows = 162;
Color green("green");
PixelPacket *pixels = view.get(38,36,columns,rows);
for ( unsigned int row = 0; row < rows ; ++row )
for ( unsigned int column = 0; column < columns ; ++column [Cache.png]
)
*pixels++=green;
view.sync();
// Set all pixels in region anchored at 86x72, with size
108x67 to yellow.
columns = 108; rows = 67;
Color yellow("yellow");
pixels = view.get(86,72,columns,rows);
for ( unsigned int row = 0; row < rows ; ++row )
for ( unsigned int column = 0; column < columns ;
++column )
*pixels++=yellow;
view.sync();
// Set pixel at position 108,94 to red
*(view.get(108,94,1,1)) = Color("red");
view.sync();
Pixels supports the following methods:
Pixel Cache Methods
Method Returns Signature Description
Transfers pixels from the
image to the pixel cache as
defined by the specified
int x_, int y_, rectangular region. Modified
get PixelPacket* unsigned int columns_, pixels may be subsequently
unsigned int rows_ transferred back to the image
via sync. The value returned
is intended for pixel access
only. It should never be
deallocated.
Allocates a pixel cache region
to store image pixels as
defined by the region
int x_, int y_, rectangle. This area is
set PixelPacket* unsigned int columns_, subsequently transferred from
unsigned int rows_ the pixel cache to the image
via sync. The value returned
is intended for pixel access
only. It should never be
deallocated.
sync void void Transfers the image cache
pixels to the image.
Returns the PsuedoColor pixel
indexes corresponding to the
pixel region defined by the
last get or set call. Only
valid for PseudoColor and
CMYKA images. The pixel
indexes (an array of type
IndexPacket, which is typedef
Quantum, which is itself
indexesIndexPacket* void typedef unsigned char, or
unsigned short, depending on
the value of the QuantumDepth
define) provide the colormap
index (see colorMap) for each
pixel in the image. For CMYKA
images, the indexes represent
the matte channel. The value
returned is intended for pixel
access only. It should never
be deallocated.
x unsigned int void Left ordinate of view
y unsigned int void Top ordinate of view
columnsunsigned int void Width of view
rows unsigned int void Height of view
\end{verbatim}
}
|
