【澳门新葡亰app平台】用强度平均法从种子点生长出一个区域进行分割,简单示例

澳门新葡亰app平台 1

  • Cairo
    • 安装
    • Cairo在PyGobject中的使用
    • cairoContext介绍
      • class
        cairoContexttarget
      • append_pathpath
      • arcxc yc radius angle1
        angle2
      • arc_negativexc yc radius angle1
        angle2
      • clip
      • clip_extents
      • clip_preserve
      • close_path
      • copy_clip_rectangle_list
      • copy_page
      • copy_path
      • copy_path_flat
      • curve_tox1 y1 x2 y2 x3
        y3
      • device_to_userx
        y
      • device_to_user_distancedx
        dy
      • fill
      • fill_extents
      • fill_preserve
      • font_extents
      • get_antialias
      • get_current_point
      • get_dash
      • get_dash_count
      • get_fill_rule
      • get_font_face
      • get_font_matrix
      • get_font_options
      • get_group_target
      • get_line_cap
      • get_line_join
      • get_line_width
      • get_matrix
      • get_miter_limit
      • get_operator
      • get_scaled_font
      • get_source
      • get_target
      • get_tolerance
      • glyph_extentsglyphs
        num_glyphs
      • glyph_pathglyphs
        num_glyphs
      • has_current_point
      • identity_matrix
      • in_fillx
        y
      • in_strokex
        y
      • line_tox
        y
      • maskpattern
      • mask_surfacesurface x00
        y00
      • move_tox
        y
      • new_path
      • new_sub_path
      • paint
      • paint_with_alphaalpha
      • path_extents
      • pop_group
      • pop_group_to_source
      • push_group
      • push_group_with_contentcontent
      • rectanglex y width
        height
      • rel_curve_todx1 dy1 dx2 dy2 dx3
        dy3
      • rel_line_todx
        dy
      • rel_move_todx
        dy
      • reset_clip
      • restore
      • rotateangle
      • save
      • scalesx
        sy
      • select_font_facefamily slant
        weight
      • set_antialiasantialias
      • set_dashdashes
        offset0
      • set_fill_rulefill_rule
      • set_font_facefont_face
      • set_font_matrixmatrix
      • set_font_optionsoptions
      • set_font_sizesize
      • set_line_capline_cap
      • set_line_joinline_join
      • set_line_widthwidth
      • set_matrixmatrix
      • set_miter_limitlimit
      • set_operatorop
      • set_scaled_fontscaled_font
      • set_sourcesource
      • set_source_rgbred green
        blue
      • set_source_rgbared green blue
        alpha10
      • set_source_surfacesurface x00
        y00
      • set_tolerancetolerance
      • show_glyphsglyphs
        num_glyphs
      • show_page
      • show_texttext
      • stroke
      • stroke_extents
      • stroke_preserve
      • text_extentstext
      • text_pathtext
      • transformmatrix
      • translatetx
        ty
      • user_to_devicex
        y
      • user_to_device_distancedx
        dy
    • 差非常少示例

本代码是从一个纯净种子点进行“区域生长”的简练但管用的例子。

Cairo

Cario是贰个2D图形库,援助种种输出设备。
时下支撑的出口目标包含X
Window,Quartz,Win32,image.buffers,PostScript,PDF和SVG文件输出。
承接帮忙OpenGL,XCB,BeOS,OS/2操作系统和DirectFB。
Cario的目标是同一输出在分化的出口媒体上,同有时间能动用硬件加快器。

重在优点:在X、Win32、Quartz的功底上联合了图形库的操作方法,同一时间协助PS、PDF、SVG、PNG/JPEG等图像格式的输出,方便页面包车型大巴再度行使,在glitz的支撑下帮忙部分3D功力。——摘自百度百科

Simple but effective example of “Region Growing” from a single seed
point.

安装

参见PyGobject(一)安装篇

该区域通过将兼具未分配的隔壁像素与该区域张开相比较来迭代生长。

Cairo在PyGobject中的使用

在PyGobject中,常常采纳Gtk.DrawingArea部件,并接二连三到Gtk.Widget
::draw
连续信号,使用回调函数中的第二个参数cairo.Context,实行绘图操作

The region is iteratively grown by comparing all unallocated
neighbouring pixels to the region.

cairo.Context介绍

Context is the main object used when drawing with cairo. To draw with
cairo, you create a Context, set the target surface, and drawing options
for the Context, create shapes with functions like Context.move_to()
and Context.line_to(), and then draw shapes with Context.stroke() or
Context.fill().

Contexts can be pushed to a stack via Context.save(). They may then
safely be changed, without loosing the current state. Use
Context.restore() to restore to the saved state.

像素强度值和区域平均值之间的歧异被用作相似性的胸襟。

class cairo.Context(target)

Parameters: target – target Surface for the context
Returns:    a newly allocated Context

Raises : MemoryError in case of no memory
Creates a new Context with all graphics state parameters set to default
values and with target as a target surface. The target surface should be
constructed with a backend-specific function such as ImageSurface (or
any other cairo backend surface create variant).

The difference between a pixel’s intensity value and the region’s mean,
is used as a measure of similarity.

append_path(path)

Parameters: path – Path to be appended

Append the path onto the current path. The path may be either the return
value from one of Context.copy_path() or Context.copy_path_flat() or
it may be constructed manually (in C).

以这种措施度量的反差极小的像素被分配到该区域。

arc(xc, yc, radius, angle1, angle2)

Parameters: 
    xc (float) – X position of the center of the arc
    yc (float) – Y position of the center of the arc
    radius (float) – the radius of the arc
    angle1 (float) – the start angle, in radians
    angle2 (float) – the end angle, in radians

Adds a circular arc of the given radius to the current path. The arc is
centered at (xc, yc), begins at angle1 and proceeds in the direction of
increasing angles to end at angle2. If angle2 is less than angle1 it
will be progressively increased by 2*PI until it is greater than
angle1.

If there is a current point, an initial line segment will be added to
the path to connect the current point to the beginning of the arc. If
this initial line is undesired, it can be avoided by calling
Context.new_sub_path() before calling Context.arc().

Angles are measured in radians. An angle of 0.0 is in the direction of
the positive X axis (in user space). An angle of PI/2.0 radians (90
degrees) is in the direction of the positive Y axis (in user space).
Angles increase in the direction from the positive X axis toward the
positive Y axis. So with the default transformation matrix, angles
increase in a clockwise direction.

To convert from degrees to radians, use degrees * (math.pi / 180).

This function gives the arc in the direction of increasing angles; see
Context.arc_negative() to get the arc in the direction of decreasing
angles.

The arc is circular in user space. To achieve an elliptical arc, you can
scale the current transformation matrix by different amounts in the X
and Y directions. For example, to draw an ellipse in the box given by x,
y, width, height:

ctx.save()
ctx.translate(x + width / 2., y + height / 2.)
ctx.scale(width / 2., height / 2.)
ctx.arc(0., 0., 1., 0., 2 * math.pi)
ctx.restore()

The pixel with the smallest difference measured this way is allocated to
the region.

arc_negative(xc, yc, radius, angle1, angle2)

Parameters: 
    xc (float) – X position of the center of the arc
    yc (float) – Y position of the center of the arc
    radius (float) – the radius of the arc
    angle1 (float) – the start angle, in radians
    angle2 (float) – the end angle, in radians

Adds a circular arc of the given radius to the current path. The arc is
centered at (xc, yc), begins at angle1 and proceeds in the direction of
decreasing angles to end at angle2. If angle2 is greater than angle1 it
will be progressively decreased by 2*PI until it is less than angle1.

See Context.arc() for more details. This function differs only in the
direction of the arc between the two angles.

当区域平均值和新像素之间的强度差大于有些固定值时,此进度截止。

clip()

Establishes a new clip region by intersecting the current clip region
with the current path as it would be filled by Context.fill() and
according to the current FILL RULE (see Context.set_fill_rule()).

After clip(), the current path will be cleared from the Context.

The current clip region affects all drawing operations by effectively
masking out any changes to the surface that are outside the current clip
region.

Calling clip() can only make the clip region smaller, never larger. But
the current clip is part of the graphics state, so a temporary
restriction of the clip region can be achieved by calling clip() within
a Context.save()/Context.restore() pair. The only other means of
increasing the size of the clip region is Context.reset_clip().

This process stops when the intensity difference between region mean and
new pixel becomes larger than a certain treshold.

clip_extents()

Returns:    (x1, y1, x2, y2)
Return type:    (float, float, float, float)
    x1: left of the resulting extents
    y1: top of the resulting extents
    x2: right of the resulting extents
    y2: bottom of the resulting extents

Computes a bounding box in user coordinates covering the area inside the
current clip.

New in version 1.4.

function J=regiongrowing(I,x,y,reg_maxdist)

clip_preserve()

Establishes a new clip region by intersecting the current clip region
with the current path as it would be filled by Context.fill() and
according to the current FILL RULE (see Context.set_fill_rule()).

Unlike Context.clip(), clip_preserve() preserves the path within the
Context.

The current clip region affects all drawing operations by effectively
masking out any changes to the surface that are outside the current clip
region.

Calling clip_preserve() can only make the clip region smaller, never
larger. But the current clip is part of the graphics state, so a
temporary restriction of the clip region can be achieved by calling
clip_preserve() within a Context.save()/Context.restore() pair. The
only other means of increasing the size of the clip region is
Context.reset_clip().

% This function performs “region growing” in an image from a specified

close_path()

Adds a line segment to the path from the current point to the beginning
of the current sub-path, (the most recent point passed to
Context.move_to()), and closes this sub-path. After this call the
current point will be at the joined endpoint of the sub-path.

The behavior of close_path() is distinct from simply calling
Context.line_to() with the equivalent coordinate in the case of
stroking. When a closed sub-path is stroked, there are no caps on the
ends of the sub-path. Instead, there is a line join connecting the final
and initial segments of the sub-path.

If there is no current point before the call to close_path(), this
function will have no effect.

Note: As of cairo version 1.2.4 any call to close_path() will place an
explicit MOVE_TO element into the path immediately after the
CLOSE_PATH element, (which can be seen in Context.copy_path() for
example). This can simplify path processing in some cases as it may not
be necessary to save the “last move_to point” during processing as the
MOVE_TO immediately after the CLOSE_PATH will provide that point.

% seedpoint

copy_clip_rectangle_list()

Returns:    the current clip region as a list of rectangles in user coordinates
Return type:    list of 4-tuples of float

(The status in the list may be %CAIRO_STATUS_CLIP_NOT_REPRESENTABLE
to indicate that the clip region cannot be represented as a list of
user-space rectangles. The status may have other values to indicate
other errors. – not implemented in pycairo)

New in version 1.4.

% J = regiongrowing

copy_page()

Emits the current page for backends that support multiple pages, but
doesn’t clear it, so, the contents of the current page will be retained
for the next page too. Use Context.show_page() if you want to get an
empty page after the emission.

This is a convenience function that simply calls Surface.copy_page() on
Context’s target.

% I : input image

copy_path()

Returns:    Path

Raises : MemoryError in case of no memory
Creates a copy of the current path and returns it to the user as a Path.

% J : logical output image of region

copy_path_flat()

Returns:    Path

Raises : MemoryError in case of no memory
Gets a flattened copy of the current path and returns it to the user as
a Path.

This function is like Context.copy_path() except that any curves in the
path will be approximated with piecewise-linear approximations,
(accurate to within the current tolerance value). That is, the result is
guaranteed to not have any elements of type CAIRO_PATH_CURVE_TO which
will instead be replaced by a series of CAIRO_PATH_LINE_TO elements.

% x,y : the position of the seedpoint (if not given uses function
getpts)

curve_to(x1, y1, x2, y2, x3, y3)

Parameters: 
    x1 (float) – the X coordinate of the first control point
    y1 (float) – the Y coordinate of the first control point
    x2 (float) – the X coordinate of the second control point
    y2 (float) – the Y coordinate of the second control point
    x3 (float) – the X coordinate of the end of the curve
    y3 (float) – the Y coordinate of the end of the curve

Adds a cubic Bézier spline to the path from the current point to
position (x3, y3) in user-space coordinates, using (x1, y1) and (x2, y2)
as the control points. After this call the current point will be (x3,
y3).

If there is no current point before the call to curve_to() this
function will behave as if preceded by a call to ctx.move_to(x1, y1).

% t : maximum intensity distance (defaults to 0.2)

device_to_user(x, y)

Parameters: 
    x (float) – X value of coordinate
    y (float) – Y value of coordinate
Returns:    
    (x, y)
Return type:    
    (float, float)

Transform a coordinate from device space to user space by multiplying
the given point by the inverse of the current transformation matrix
(CTM).

% The region is iteratively grown by comparing all unallocated
neighbouring pixels to the region.

device_to_user_distance(dx, dy)

Parameters: 
    dx (float) – X component of a distance vector
    dy (float) – Y component of a distance vector
Returns:    
    (dx, dy)
Return type:    
    (float, float)

Transform a distance vector from device space to user space. This
function is similar to Context.device_to_user() except that the
translation components of the inverse CTM will be ignored when
transforming (dx,dy).

% The difference between a pixel’s intensity value and the region’s
mean,

fill()

A drawing operator that fills the current path according to the current
FILL RULE, (each sub-path is implicitly closed before being filled).
After fill(), the current path will be cleared from the Context. See
Context.set_fill_rule() and Context.fill_preserve().

% is used as a measure of similarity. The pixel with the smallest
difference

fill_extents()

Returns:    (x1, y1, x2, y2)
Return type:    (float, float, float, float)
    x1: left of the resulting extents
    y1: top of the resulting extents
    x2: right of the resulting extents
    y2: bottom of the resulting extents

Computes a bounding box in user coordinates covering the area that would
be affected, (the “inked” area), by a Context.fill() operation given the
current path and fill parameters. If the current path is empty, returns
an empty rectangle (0,0,0,0). Surface dimensions and clipping are not
taken into account.

Contrast with Context.path_extents(), which is similar, but returns
non-zero extents for some paths with no inked area, (such as a simple
line segment).

Note that fill_extents() must necessarily do more work to compute the
precise inked areas in light of the fill rule, so
Context.path_extents() may be more desirable for sake of performance if
the non-inked path extents are desired.

See Context.fill(), Context.set_fill_rule() and
Context.fill_preserve().

% measured this way is allocated to the respective region.

fill_preserve()

A drawing operator that fills the current path according to the current
FILL RULE, (each sub-path is implicitly closed before being filled).
Unlike Context.fill(), fill_preserve() preserves the path within the
Context.

See Context.set_fill_rule() and Context.fill().

% This process stops when the intensity difference between region mean
and

font_extents()

Returns:    (ascent, descent, height, max_x_advance, max_y_advance)
Return type:    (float, float, float, float, float)

Gets the font extents for the currently selected font.

% new pixel become larger than a certain treshold

get_antialias()

Returns:    the current ANTIALIAS mode, as set by Context.set_antialias().

% I = im2double(imread(‘medtest.png’));

get_current_point()

Returns:    (x, y)
Return type:    (float, float)
    x: X coordinate of the current point
    y: Y coordinate of the current point

Gets the current point of the current path, which is conceptually the
final point reached by the path so far.

The current point is returned in the user-space coordinate system. If
there is no defined current point or if Context is in an error status, x
and y will both be set to 0.0. It is possible to check this in advance
with Context.has_current_point().

Most path construction functions alter the current point. See the
following for details on how they affect the current point:
Context.new_path(), Context.new_sub_path(), Context.append_path(),
Context.close_path(), Context.move_to(), Context.line_to(),
Context.curve_to(), Context.rel_move_to(), Context.rel_line_to(),
Context.rel_curve_to(), Context.arc(), Context.arc_negative(),
Context.rectangle(), Context.text_path(), Context.glyph_path(),
Context.stroke_to_path().

Some functions use and alter the current point but do not otherwise
change current path: Context.show_text().

Some functions unset the current path and as a result, current point:
Context.fill(), Context.stroke().

% x=198; y=359;

get_dash()

Returns:    (dashes, offset)
Return type:    (tuple, float)
    dashes: return value for the dash array
    offset: return value for the current dash offset

Gets the current dash array.

New in version 1.4.

% J = regiongrowing(I,x,y,0.2);

get_dash_count()

Returns:    the length of the dash array, or 0 if no dash array set.
Return type:    int

See also Context.set_dash() and Context.get_dash().

New in version 1.4.

% figure, imshow;

get_fill_rule()

Returns:    the current FILL RULE, as set by Context.set_fill_rule().

% Author: D. Kroon, University of Twente

get_font_face()

Returns:    the current FontFace for the Context.

if(exist(‘reg_maxdist’,’var’)==0), reg_maxdist=0.2; end

get_font_matrix()

Returns:    the current Matrix for the Context.

See Context.set_font_matrix().

if(exist(‘y’,’var’)==0), figure, imshow; [y,x]=getpts; y=round;
x=round; end

get_font_options()

Returns:    the current FontOptions for the Context.

Retrieves font rendering options set via Context.set_font_options().
Note that the returned options do not include any options derived from
the underlying surface; they are literally the options passed to
Context.set_font_options().

J = zeros; % Output

get_group_target()

Returns:    the target Surface.

Gets the current destination Surface for the Context. This is either the
original target surface as passed to Context or the target surface for
the current group as started by the most recent call to
Context.push_group() or Context.push_group_with_content().

New in version 1.2.

Isizes = size; % Dimensions of input image

get_line_cap()

Returns:    the current LINE_CAP style, as set by Context.set_line_cap().

reg_mean = I; % The mean of the segmented region

get_line_join()

Returns:    the current LINE_JOIN style, as set by Context.set_line_join().

reg_size = 1; % Number of pixels in region

get_line_width()

Returns:    the current line width
Return type:    float

This function returns the current line width value exactly as set by
Context.set_line_width(). Note that the value is unchanged even if the
CTM has changed between the calls to Context.set_line_width() and
get_line_width().

% Free memory to store neighbours of the (segmented) region

get_matrix()

Returns:    the current transformation Matrix (CTM)

neg_free = 10000; neg_pos=0;

get_miter_limit()

Returns:    the current miter limit, as set by Context.set_miter_limit().
Return type:    float

neg_list = zeros(neg_free,3);

get_operator()

Returns:    the current compositing OPERATOR for a Context.

pixdist=0; % Distance of the region newest pixel to the regio mean

get_scaled_font()

Returns:    the current ScaledFont for a Context.

New in version 1.4.

% Neighbor locations (footprint)

get_source()

Returns:    the current source Pattern for a Context.

neigb=[-1 0; 1 0; 0 -1;0 1];

get_target()

Returns:    the target Surface for the Context

% Start regiogrowing until distance between regio and posible new pixels
become

get_tolerance()

Returns:    the current tolerance value, as set by Context.set_tolerance()
Return type:    float

% higher than a certain treshold

glyph_extents(glyphs[, num_glyphs])

Parameters: 
    glyphs (a sequence of (int, float, float)) – glyphs
    num_glyphs (int) – number of glyphs to measure, defaults to using all
Returns:    
    x_bearing, y_bearing, width, height, x_advance, y_advance
Return type:    
    6-tuple of float

Gets the extents for an array of glyphs. The extents describe a
user-space rectangle that encloses the “inked” portion of the glyphs,
(as they would be drawn by Context.show_glyphs()). Additionally, the
x_advance and y_advance values indicate the amount by which the
current point would be advanced by Context.show_glyphs().

Note that whitespace glyphs do not contribute to the size of the
rectangle (extents.width and extents.height).

while(pixdist<reg_maxdist&&reg_size<numel

glyph_path(glyphs[, num_glyphs])

Parameters: 
    glyphs (a sequence of (int, float, float)) – glyphs to show
    num_glyphs (int) – number of glyphs to show, defaults to showing all

Adds closed paths for the glyphs to the current path. The generated path
if filled, achieves an effect similar to that of Context.show_glyphs().

% Add new neighbors pixels

has_current_point()

returns: True iff a current point is defined on the current path.

See Context.get_current_point() for details on the current point.
New in version 1.6.

for j=1:4,

identity_matrix()

Resets the current transformation Matrix (CTM) by setting it equal to
the identity matrix. That is, the user-space and device-space axes will
be aligned and one user-space unit will transform to one device-space
unit.

% Calculate the neighbour coordinate

in_fill(x, y)

Parameters: 
    x (float) – X coordinate of the point to test
    y (float) – Y coordinate of the point to test
Returns:    
    True iff the point is inside the area that would be affected by a Context.fill() operation given the current path and filling parameters. Surface dimensions and clipping are not taken into account.

See Context.fill(), Context.set_fill_rule() and
Context.fill_preserve().

xn = x +neigb; yn = y +neigb;

in_stroke(x, y)

Parameters: 
    x (float) – X coordinate of the point to test
    y (float) – Y coordinate of the point to test
Returns:    
    True iff the point is inside the area that would be affected by a Context.stroke() operation given the current path and stroking parameters. Surface dimensions and clipping are not taken into account.

See Context.stroke(), Context.set_line_width(),
Context.set_line_join(), Context.set_line_cap(),
Context.set_dash(), and Context.stroke_preserve().

% Check if neighbour is inside or outside the image

line_to(x, y)

Parameters: 
    x (float) – the X coordinate of the end of the new line
    y (float) – the Y coordinate of the end of the new line

Adds a line to the path from the current point to position (x, y) in
user-space coordinates. After this call the current point will be (x,
y).

If there is no current point before the call to line_to() this function
will behave as ctx.move_to(x, y).

ins=&&&&(xn<=Isizes&&(yn<=Isizes;

mask(pattern)

Parameters: pattern – a Pattern

A drawing operator that paints the current source using the alpha
channel of pattern as a mask. (Opaque areas of pattern are painted with
the source, transparent areas are not painted.)

% Add neighbor if inside and not already part of the segmented area

mask_surface(surface, x=0.0, y=0.0)

Parameters: 
    surface – a Surface
    x (float) – X coordinate at which to place the origin of surface
    y (float) – Y coordinate at which to place the origin of surface

A drawing operator that paints the current source using the alpha
channel of surface as a mask. (Opaque areas of surface are painted with
the source, transparent areas are not painted.)

if(ins&&==0))

move_to(x, y)

Parameters: 
    x (float) – the X coordinate of the new position
    y (float) – the Y coordinate of the new position

Begin a new sub-path. After this call the current point will be (x, y).

neg_pos = neg_pos+1;

new_path()

Clears the current path. After this call there will be no path and no
current point.

neg_list(neg_pos,:) = [xn yn I]; J=1;

new_sub_path()

Begin a new sub-path. Note that the existing path is not affected. After
this call there will be no current point.

In many cases, this call is not needed since new sub-paths are
frequently started with Context.move_to().

A call to new_sub_path() is particularly useful when beginning a new
sub-path with one of the Context.arc() calls. This makes things easier
as it is no longer necessary to manually compute the arc’s initial
coordinates for a call to Context.move_to().

New in version 1.6.

% Add a new block of free memory

paint()

A drawing operator that paints the current source everywhere within the
current clip region.

if(neg_pos+10>neg_free), neg_free=neg_free+10000;
neg_list((neg_pos+1):neg_free,:)=0; end

paint_with_alpha(alpha)

Parameters: alpha (float) – alpha value, between 0 (transparent) and 1 (opaque)

A drawing operator that paints the current source everywhere within the
current clip region using a mask of constant alpha value alpha. The
effect is similar to Context.paint(), but the drawing is faded out using
the alpha value.

% Add pixel with intensity nearest to the mean of the region, to the
region

path_extents()

Returns:    (x1, y1, x2, y2)
Return type:    (float, float, float, float)
    x1: left of the resulting extents
    y1: top of the resulting extents
    x2: right of the resulting extents
    y2: bottom of the resulting extents

Computes a bounding box in user-space coordinates covering the points on
the current path. If the current path is empty, returns an empty
rectangle (0, 0, 0, 0). Stroke parameters, fill rule, surface dimensions
and clipping are not taken into account.

Contrast with Context.fill_extents() and Context.stroke_extents()
which return the extents of only the area that would be “inked” by the
corresponding drawing operations.

The result of path_extents() is defined as equivalent to the limit of
Context.stroke_extents() with cairo.LINE_CAP_ROUND as the line width
approaches 0.0, (but never reaching the empty-rectangle returned by
Context.stroke_extents() for a line width of 0.0).

Specifically, this means that zero-area sub-paths such as
Context.move_to(); Context.line_to() segments, (even degenerate cases
where the coordinates to both calls are identical), will be considered
as contributing to the extents. However, a lone Context.move_to() will
not contribute to the results of Context.path_extents().

New in version 1.6.

dist = abs(neg_list(1:neg_pos,3)-reg_mean);

pop_group()

Returns:    a newly created SurfacePattern containing the results of all drawing operations performed to the group.

Terminates the redirection begun by a call to Context.push_group() or
Context.push_group_with_content() and returns a new pattern
containing the results of all drawing operations performed to the group.

The pop_group() function calls Context.restore(), (balancing a call to
Context.save() by the Context.push_group() function), so that any
changes to the graphics state will not be visible outside the group.

New in version 1.2.

[pixdist, index] = min;

pop_group_to_source()

Terminates the redirection begun by a call to Context.push_group() or
Context.push_group_with_content() and installs the resulting pattern
as the source Pattern in the given Context.

The behavior of this function is equivalent to the sequence of
operations:

group = cairo_pop_group()
ctx.set_source(group)

but is more convenient as their is no need for a variable to store the
short-lived pointer to the pattern.

The Context.pop_group() function calls Context.restore(), (balancing a
call to Context.save() by the Context.push_group() function), so that
any changes to the graphics state will not be visible outside the group.

New in version 1.2.

J=2; reg_size=reg_size+1;

push_group()

Temporarily redirects drawing to an intermediate surface known as a
group. The redirection lasts until the group is completed by a call to
Context.pop_group() or Context.pop_group_to_source(). These calls
provide the result of any drawing to the group as a pattern, (either as
an explicit object, or set as the source pattern).

This group functionality can be convenient for performing intermediate
compositing. One common use of a group is to render objects as opaque
within the group, (so that they occlude each other), and then blend the
result with translucence onto the destination.

Groups can be nested arbitrarily deep by making balanced calls to
Context.push_group()/Context.pop_group(). Each call pushes/pops the
new target group onto/from a stack.

The push_group() function calls Context.save() so that any changes to
the graphics state will not be visible outside the group, (the
pop_group functions call Context.restore()).

By default the intermediate group will have a CONTENT type of
cairo.CONTENT_COLOR_ALPHA. Other content types can be chosen for the
group by using Context.push_group_with_content() instead.

As an example, here is how one might fill and stroke a path with
translucence, but without any portion of the fill being visible under
the stroke:

ctx.push_group()
ctx.set_source(fill_pattern)
ctx.fill_preserve()
ctx.set_source(stroke_pattern)
ctx.stroke()
ctx.pop_group_to_source()
ctx.paint_with_alpha(alpha)

New in version 1.2.

% Calculate the new mean of the region

push_group_with_content(content)

Parameters: content – a CONTENT indicating the type of group that will be created

Temporarily redirects drawing to an intermediate surface known as a
group. The redirection lasts until the group is completed by a call to
Context.pop_group() or Context.pop_group_to_source(). These calls
provide the result of any drawing to the group as a pattern, (either as
an explicit object, or set as the source pattern).

The group will have a content type of content. The ability to control
this content type is the only distinction between this function and
Context.push_group() which you should see for a more detailed
description of group rendering.

New in version 1.2.

reg_mean= (reg_mean*reg_size + neg_list/(reg_size+1);

rectangle(x, y, width, height)

Parameters: 
    x (float) – the X coordinate of the top left corner of the rectangle
    y (float) – the Y coordinate to the top left corner of the rectangle
    width (float) – the width of the rectangle
    height (float) – the height of the rectangle

Adds a closed sub-path rectangle of the given size to the current path
at position (x, y) in user-space coordinates.

This function is logically equivalent to:

ctx.move_to(x, y)
ctx.rel_line_to(width, 0)
ctx.rel_line_to(0, height)
ctx.rel_line_to(-width, 0)
ctx.close_path()

% Save the x and y coordinates of the pixel (for the neighbour add
proccess)

rel_curve_to(dx1, dy1, dx2, dy2, dx3, dy3)

Parameters: 
    dx1 (float) – the X offset to the first control point
    dy1 (float) – the Y offset to the first control point
    dx2 (float) – the X offset to the second control point
    dy2 (float) – the Y offset to the second control point
    dx3 (float) – the X offset to the end of the curve
    dy3 (float) – the Y offset to the end of the curve

Raises :
cairo.Error if called with no current point.
Relative-coordinate version of Context.curve_to(). All offsets are
relative to the current point. Adds a cubic Bézier spline to the path
from the current point to a point offset from the current point by (dx3,
dy3), using points offset by (dx1, dy1) and (dx2, dy2) as the control
points. After this call the current point will be offset by (dx3, dy3).

Given a current point of (x, y), ctx.rel_curve_to(dx1, dy1, dx2, dy2,
dx3, dy3) is logically equivalent to ctx.curve_to(x+dx1, y+dy1, x+dx2,
y+dy2, x+dx3, y+dy3).

x = neg_list; y = neg_list;

rel_line_to(dx, dy)

Parameters: 
    dx (float) – the X offset to the end of the new line
    dy (float) – the Y offset to the end of the new line

Raises :
cairo.Error if called with no current point.
Relative-coordinate version of Context.line_to(). Adds a line to the
path from the current point to a point that is offset from the current
point by (dx, dy) in user space. After this call the current point will
be offset by (dx, dy).

Given a current point of (x, y), ctx.rel_line_to(dx, dy) is logically
equivalent to ctx.line_to(x + dx, y + dy).

% Remove the pixel from the neighbour list

rel_move_to(dx, dy)

Parameters: 
    dx (float) – the X offset
    dy (float) – the Y offset

Raises :
cairo.Error if called with no current point.
Begin a new sub-path. After this call the current point will offset by
(dx, dy).

Given a current point of (x, y), ctx.rel_move_to(dx, dy) is logically
equivalent to ctx.(x + dx, y + dy).

neg_list=neg_list(neg_pos,:); neg_pos=neg_pos-1;

reset_clip()

Reset the current clip region to its original, unrestricted state. That
is, set the clip region to an infinitely large shape containing the
target surface. Equivalently, if infinity is too hard to grasp, one can
imagine the clip region being reset to the exact bounds of the target
surface.

Note that code meant to be reusable should not call reset_clip() as it
will cause results unexpected by higher-level code which calls clip().
Consider using save() and restore() around clip() as a more robust means
of temporarily restricting the clip region.

% Return the segmented area as logical matrix

restore()

Restores Context to the state saved by a preceding call to save() and
removes that state from the stack of saved states.

rotate(angle)

Parameters: angle (float) – angle (in radians) by which the user-space axes will be rotated

Modifies the current transformation matrix (CTM) by rotating the
user-space axes by angle radians. The rotation of the axes takes places
after any existing transformation of user space. The rotation direction
for positive angles is from the positive X axis toward the positive Y
axis.

越来越多精彩小说请关切微时域信号:澳门新葡亰app平台 2

save()

Makes a copy of the current state of Context and saves it on an internal
stack of saved states. When restore() is called, Context will be
restored to the saved state. Multiple calls to save() and restore() can
be nested; each call to restore() restores the state from the matching
paired save().

scale(sx, sy)

Parameters: 
    sx (float) – scale factor for the X dimension
    sy (float) – scale factor for the Y dimension

Modifies the current transformation matrix (CTM) by scaling the X and Y
user-space axes by sx and sy respectively. The scaling of the axes takes
place after any existing transformation of user space.

select_font_face(family[, slant[, weight]])

Parameters: 
    family (str) – a font family name
    slant – the FONT_SLANT of the font, defaults to cairo.FONT_SLANT_NORMAL.
    weight – the FONT_WEIGHT of the font, defaults to cairo.FONT_WEIGHT_NORMAL.

Note: The select_font_face() function call is part of what the cairo
designers call the “toy” text API. It is convenient for short demos and
simple programs, but it is not expected to be adequate for serious
text-using applications.

Selects a family and style of font from a simplified description as a
family name, slant and weight. Cairo provides no operation to list
available family names on the system (this is a “toy”, remember), but
the standard CSS2 generic family names, (“serif”, “sans-serif”,
“cursive”, “fantasy”, “monospace”), are likely to work as expected.

For “real” font selection, see the font-backend-specific
font_face_create functions for the font backend you are using. (For
example, if you are using the freetype-based cairo-ft font backend, see
cairo_ft_font_face_create_for_ft_face() or
cairo_ft_font_face_create_for_pattern().) The resulting font face
could then be used with cairo_scaled_font_create() and
cairo_set_scaled_font().

Similarly, when using the “real” font support, you can call directly
into the underlying font system, (such as fontconfig or freetype), for
operations such as listing available fonts, etc.

It is expected that most applications will need to use a more
comprehensive font handling and text layout library, (for example,
pango), in conjunction with cairo.

If text is drawn without a call to select_font_face(), (nor
set_font_face() nor set_scaled_font()), the default family is
platform-specific, but is essentially “sans-serif”. Default slant is
cairo.FONT_SLANT_NORMAL, and default weight is
cairo.FONT_WEIGHT_NORMAL.

This function is equivalent to a call to ToyFontFace followed by
set_font_face().

set_antialias(antialias)

Parameters: antialias – the new ANTIALIAS mode

Set the antialiasing mode of the rasterizer used for drawing shapes.
This value is a hint, and a particular backend may or may not support a
particular value. At the current time, no backend supports
cairo.ANTIALIAS_SUBPIXEL when drawing shapes.

Note that this option does not affect text rendering, instead see
FontOptions.set_antialias().

set_dash(dashes[, offset=0])

Parameters: 
    dashes (sequence of float) – a sequence specifying alternate lengths of on and off stroke portions.
    offset (int) – an offset into the dash pattern at which the stroke should start, defaults to 0.

Raises :
cairo.Error if any value in dashes is negative, or if all values are

  1. Sets the dash pattern to be used by stroke(). A dash pattern is
    specified by dashes – a sequence of positive values. Each value provides
    the length of alternate “on” and “off” portions of the stroke. The
    offset specifies an offset into the pattern at which the stroke begins.

Each “on” segment will have caps applied as if the segment were a
separate sub-path. In particular, it is valid to use an “on” length of
0.0 with cairo.LINE_CAP_ROUND or cairo.LINE_CAP_SQUARE in order to
distributed dots or squares along a path.

Note: The length values are in user-space units as evaluated at the time
of stroking. This is not necessarily the same as the user space at the
time of set_dash().

If the number of dashes is 0 dashing is disabled.

If the number of dashes is 1 a symmetric pattern is assumed with
alternating on and off portions of the size specified by the single
value in dashes.

set_fill_rule(fill_rule)

Parameters: fill_rule – a FILL RULE to set the within the cairo context. The fill rule is used to determine which regions are inside or outside a complex (potentially self-intersecting) path. The current fill rule affects both fill() and clip().

The default fill rule is cairo.FILL_RULE_WINDING.

set_font_face(font_face)

Parameters: font_face – a FontFace, or None to restore to the default FontFace

Replaces the current FontFace object in the Context with font_face.

set_font_matrix(matrix)

Parameters: matrix – a Matrix describing a transform to be applied to the current font.

Sets the current font matrix to matrix. The font matrix gives a
transformation from the design space of the font (in this space, the
em-square is 1 unit by 1 unit) to user space. Normally, a simple scale
is used (see set_font_size()), but a more complex font matrix can be
used to shear the font or stretch it unequally along the two axes

set_font_options(options)

Parameters: options – FontOptions to use

Sets a set of custom font rendering options for the Context. Rendering
options are derived by merging these options with the options derived
from underlying surface; if the value in options has a default value
(like cairo.ANTIALIAS_DEFAULT), then the value from the surface is
used.

set_font_size(size)

Parameters: size (float) – the new font size, in user space units

Sets the current font matrix to a scale by a factor of size, replacing
any font matrix previously set with set_font_size() or
set_font_matrix(). This results in a font size of size user space
units. (More precisely, this matrix will result in the font’s em-square
being a size by size square in user space.)

If text is drawn without a call to set_font_size(), (nor
set_font_matrix() nor set_scaled_font()), the default font size is
10.0.

set_line_cap(line_cap)

Parameters: line_cap – a LINE_CAP style

Sets the current line cap style within the Context.

As with the other stroke parameters, the current line cap style is
examined by stroke(), stroke_extents(), and stroke_to_path(), but
does not have any effect during path construction.

The default line cap style is cairo.LINE_CAP_BUTT.

set_line_join(line_join)

Parameters: line_join – a LINE_JOIN style

Sets the current line join style within the Context.

As with the other stroke parameters, the current line join style is
examined by stroke(), stroke_extents(), and stroke_to_path(), but
does not have any effect during path construction.

The default line join style is cairo.LINE_JOIN_MITER.

set_line_width(width)

Parameters: width (float) – a line width

Sets the current line width within the Context. The line width value
specifies the diameter of a pen that is circular in user space, (though
device-space pen may be an ellipse in general due to
scaling/shear/rotation of the CTM).

Note: When the description above refers to user space and CTM it refers
to the user space and CTM in effect at the time of the stroking
operation, not the user space and CTM in effect at the time of the call
to set_line_width(). The simplest usage makes both of these spaces
identical. That is, if there is no change to the CTM between a call to
set_line_width() and the stroking operation, then one can just pass
user-space values to set_line_width() and ignore this note.

As with the other stroke parameters, the current line width is examined
by stroke(), stroke_extents(), and stroke_to_path(), but does not
have any effect during path construction.

The default line width value is 2.0.

set_matrix(matrix)

Parameters: matrix – a transformation Matrix from user space to device space.

Modifies the current transformation matrix (CTM) by setting it equal to
matrix.

set_miter_limit(limit)

Parameters: limit – miter limit to set

Sets the current miter limit within the Context.

If the current line join style is set to cairo.LINE_JOIN_MITER (see
set_line_join()), the miter limit is used to determine whether the
lines should be joined with a bevel instead of a miter. Cairo divides
the length of the miter by the line width. If the result is greater than
the miter limit, the style is converted to a bevel.

As with the other stroke parameters, the current line miter limit is
examined by stroke(), stroke_extents(), and stroke_to_path(), but
does not have any effect during path construction.

The default miter limit value is 10.0, which will convert joins with
interior angles less than 11 degrees to bevels instead of miters. For
reference, a miter limit of 2.0 makes the miter cutoff at 60 degrees,
and a miter limit of 1.414 makes the cutoff at 90 degrees.

A miter limit for a desired angle can be computed as:

miter limit = 1/math.sin(angle/2)

set_operator(op)

Parameters: op – the compositing OPERATOR to set for use in all drawing operations.

The default operator is cairo.OPERATOR_OVER.

set_scaled_font(scaled_font)

Parameters: scaled_font – a ScaledFont

Replaces the current font face, font matrix, and font options in the
Context with those of the ScaledFont. Except for some translation, the
current CTM of the Context should be the same as that of the ScaledFont,
which can be accessed using ScaledFont.get_ctm().

New in version 1.2.

set_source(source)

Parameters: source – a Pattern to be used as the source for subsequent drawing operations.

Sets the source pattern within Context to source. This pattern will then
be used for any subsequent drawing operation until a new source pattern
is set.

Note: The pattern’s transformation matrix will be locked to the user
space in effect at the time of set_source(). This means that further
modifications of the current transformation matrix will not affect the
source pattern. See Pattern.set_matrix().

The default source pattern is a solid pattern that is opaque black,
(that is, it is equivalent to set_source_rgb(0.0, 0.0, 0.0).

set_source_rgb(red, green, blue)

Parameters: 
    red (float) – red component of color
    green (float) – green component of color
    blue (float) – blue component of color

Sets the source pattern within Context to an opaque color. This opaque
color will then be used for any subsequent drawing operation until a new
source pattern is set.

The color components are floating point numbers in the range 0 to 1. If
the values passed in are outside that range, they will be clamped.

The default source pattern is opaque black, (that is, it is equivalent
to set_source_rgb(0.0, 0.0, 0.0).

set_source_rgba(red, green, blue[, alpha=1.0])

Parameters: 
    red (float) – red component of color
    green (float) – green component of color
    blue (float) – blue component of color
    alpha (float) – alpha component of color

Sets the source pattern within Context to a translucent color. This
color will then be used for any subsequent drawing operation until a new
source pattern is set.

The color and alpha components are floating point numbers in the range 0
to 1. If the values passed in are outside that range, they will be
clamped.

The default source pattern is opaque black, (that is, it is equivalent
to set_source_rgba(0.0, 0.0, 0.0, 1.0).

set_source_surface(surface[, x=0.0[, y=0.0]])

Parameters: 
    surface – a Surface to be used to set the source pattern
    x (float) – User-space X coordinate for surface origin
    y (float) – User-space Y coordinate for surface origin

This is a convenience function for creating a pattern from a Surface and
setting it as the source in Context with set_source().

The x and y parameters give the user-space coordinate at which the
surface origin should appear. (The surface origin is its upper-left
corner before any transformation has been applied.) The x and y patterns
are negated and then set as translation values in the pattern matrix.

Other than the initial translation pattern matrix, as described above,
all other pattern attributes, (such as its extend mode), are set to the
default values as in SurfacePattern. The resulting pattern can be
queried with get_source() so that these attributes can be modified if
desired, (eg. to create a repeating pattern with Pattern.set_extend()).

set_tolerance(tolerance)

Parameters: tolerance (float) – the tolerance, in device units (typically pixels)

Sets the tolerance used when converting paths into trapezoids. Curved
segments of the path will be subdivided until the maximum deviation
between the original path and the polygonal approximation is less than
tolerance. The default value is 0.1. A larger value will give better
performance, a smaller value, better appearance. (Reducing the value
from the default value of 0.1 is unlikely to improve appearance
significantly.) The accuracy of paths within Cairo is limited by the
precision of its internal arithmetic, and the prescribed tolerance is
restricted to the smallest representable internal value.

show_glyphs(glyphs[, num_glyphs])

Parameters: 
    glyphs (a sequence of (int, float, float)) – glyphs to show
    num_glyphs (int) – number of glyphs to show, defaults to showing all glyphs

A drawing operator that generates the shape from an array of glyphs,
rendered according to the current font face, font size (font matrix),
and font options.

show_page()

Emits and clears the current page for backends that support multiple
pages. Use copy_page() if you don’t want to clear the page.

This is a convenience function that simply calls ctx.get_target() .
show_page()

show_text(text)

Parameters: text (str) – text

A drawing operator that generates the shape from a string of text,
rendered according to the current font_face, font_size (font_matrix),
and font_options.

This function first computes a set of glyphs for the string of text. The
first glyph is placed so that its origin is at the current point. The
origin of each subsequent glyph is offset from that of the previous
glyph by the advance values of the previous glyph.

After this call the current point is moved to the origin of where the
next glyph would be placed in this same progression. That is, the
current point will be at the origin of the final glyph offset by its
advance values. This allows for easy display of a single logical string
with multiple calls to show_text().

Note: The show_text() function call is part of what the cairo designers
call the “toy” text API. It is convenient for short demos and simple
programs, but it is not expected to be adequate for serious text-using
applications. See show_glyphs() for the “real” text display API in
cairo.

stroke()

A drawing operator that strokes the current path according to the
current line width, line join, line cap, and dash settings. After
stroke(), the current path will be cleared from the cairo context. See
set_line_width(), set_line_join(), set_line_cap(), set_dash(),
and stroke_preserve().

Note: Degenerate segments and sub-paths are treated specially and
provide a useful result. These can result in two different situations:

  1. Zero-length “on” segments set in set_dash(). If the cap style is
    cairo.LINE_CAP_ROUND or cairo.LINE_CAP_SQUARE then these
    segments will be drawn as circular dots or squares respectively. In
    the case of cairo.LINE_CAP_SQUARE, the orientation of the squares
    is determined by the direction of the underlying path.

  2. A sub-path created by move_to() followed by either a close_path()
    or one or more calls to line_to() to the same coordinate as the
    move_to(). If the cap style is cairo.LINE_CAP_ROUND then these
    sub-paths will be drawn as circular dots. Note that in the case of
    cairo.LINE_CAP_SQUARE a degenerate sub-path will not be drawn at
    all, (since the correct orientation is indeterminate).

In no case will a cap style of cairo.LINE_CAP_BUTT cause anything to
be drawn in the case of either degenerate segments or sub-paths.

stroke_extents()

Returns:    (x1, y1, x2, y2)
Return type:    (float, float, float, float)
    x1: left of the resulting extents
    y1: top of the resulting extents
    x2: right of the resulting extents
    y2: bottom of the resulting extents

Computes a bounding box in user coordinates covering the area that would
be affected, (the “inked” area), by a stroke() operation given the
current path and stroke parameters. If the current path is empty,
returns an empty rectangle (0, 0, 0, 0). Surface dimensions and clipping
are not taken into account.

Note that if the line width is set to exactly zero, then
stroke_extents() will return an empty rectangle. Contrast with
path_extents() which can be used to compute the non-empty bounds as the
line width approaches zero.

Note that stroke_extents() must necessarily do more work to compute the
precise inked areas in light of the stroke parameters, so
path_extents() may be more desirable for sake of performance if
non-inked path extents are desired.

See stroke(), set_line_width(), set_line_join(), set_line_cap(),
set_dash(), and stroke_preserve().

stroke_preserve()

A drawing operator that strokes the current path according to the
current line width, line join, line cap, and dash settings. Unlike
stroke(), stroke_preserve() preserves the path within the cairo
context.

See set_line_width(), set_line_join(), set_line_cap(),
set_dash(), and stroke_preserve().

text_extents(text)

Parameters: text (str) – text to get extents for
Returns:    x_bearing, y_bearing, width, height, x_advance, y_advance
Return type:    6-tuple of float

Gets the extents for a string of text. The extents describe a user-space
rectangle that encloses the “inked” portion of the text, (as it would be
drawn by Context.show_text()). Additionally, the x_advance and
y_advance values indicate the amount by which the current point would
be advanced by Context.show_text().

Note that whitespace characters do not directly contribute to the size
of the rectangle (extents.width and extents.height). They do contribute
indirectly by changing the position of non-whitespace characters. In
particular, trailing whitespace characters are likely to not affect the
size of the rectangle, though they will affect the x_advance and
y_advance values.

text_path(text)

Parameters: text (str) – text

Adds closed paths for text to the current path. The generated path if
filled, achieves an effect similar to that of Context.show_text().

Text conversion and positioning is done similar to Context.show_text().

Like Context.show_text(), After this call the current point is moved to
the origin of where the next glyph would be placed in this same
progression. That is, the current point will be at the origin of the
final glyph offset by its advance values. This allows for chaining
multiple calls to to Context.text_path() without having to set current
point in between.

Note: The text_path() function call is part of what the cairo designers
call the “toy” text API. It is convenient for short demos and simple
programs, but it is not expected to be adequate for serious text-using
applications. See Context.glyph_path() for the “real” text path API in
cairo.

transform(matrix)

Parameters: matrix – a transformation Matrix to be applied to the user-space axes

Modifies the current transformation matrix (CTM) by applying matrix as
an additional transformation. The new transformation of user space takes
place after any existing transformation.

translate(tx, ty)

Parameters: 
    tx (float) – amount to translate in the X direction
    ty (float) – amount to translate in the Y direction

Modifies the current transformation matrix (CTM) by translating the
user-space origin by (tx, ty). This offset is interpreted as a
user-space coordinate according to the CTM in place before the new call
to translate(). In other words, the translation of the user-space origin
takes place after any existing transformation.

user_to_device(x, y)

Parameters: 
    x (float) – X value of coordinate
    y (float) – Y value of coordinate
Returns:(x, y)
Return type:(float, float)
    x: X value of coordinate
    y: Y value of coordinate

Transform a coordinate from user space to device space by multiplying
the given point by the current transformation matrix (CTM).

user_to_device_distance(dx, dy)

Parameters: 
    dx (float) – X value of a distance vector
    dy (float) – Y value of a distance vector

Returns:(dx, dy)
Return type:(float, float)
    dx: X value of a distance vector
    dy: Y value of a distance vector

Transform a distance vector from user space to device space. This
function is similar to Context.user_to_device() except that the
translation components of the CTM will be ignored when transforming
(dx,dy).

粗略示例

澳门新葡亰app平台 3
代码:

#!/usr/bin/env python3
# Created by xiaosanyu at 16/7/6
# section 143
TITLE = "Simple drawing"
DESCRIPTION = """
The stroke operation draws the outlines of shapes and the fill operation
fills the insides of shapes. Next we will demonstrate these two operations
"""

import gi

gi.require_version("Gtk", "3.0")
from gi.repository import Gtk

import math


class PyApp(Gtk.Window):
    def __init__(self):
        super(PyApp, self).__init__()
        self.set_title("Simple drawing")
        self.resize(230, 150)
        self.connect("destroy", Gtk.main_quit)
        darea = Gtk.DrawingArea()
        darea.connect("draw", self.draw)
        self.add(darea)
        self.show_all()

    @staticmethod
    def draw(drawingArea, cr):
        # 获取宽和高
        w = drawingArea.get_allocated_width()
        h = drawingArea.get_allocated_height()
        # 设置线条宽度
        cr.set_line_width(9)
        # 设置颜色为暗红色
        cr.set_source_rgb(0.7, 0.2, 0.0)
        # 移动到区域中心位置
        cr.translate(w / 2, h / 2)
        # 已半径为50 画一个圆
        cr.arc(0, 0, 50, 0, 2 * math.pi)
        # 描边,stroke()方法会清除路径信息.后续再填充其它颜色无效
        cr.stroke_preserve()
        # cr.stroke()
        # 设置颜色为蓝色
        cr.set_source_rgb(0.3, 0.4, 0.6)
        # 填充
        cr.fill()


def main():
    PyApp()
    Gtk.main()


if __name__ == "__main__":
    main()

代码下载地址:

发表评论

电子邮件地址不会被公开。 必填项已用*标注