Scons V3.0.5：Mapnik符号化引擎与agg库升级

需积分: 12 146 浏览量更新于2024-07-15 收藏 2.44MB PDF 举报

Scons V3.0.5 是一个强大的构建工具，主要用于自动化软件开发过程中的编译、链接和部署任务。它支持多种编程语言，如C++和Python，并且特别适用于图形处理库，如libagg，这在地图渲染和图形输出领域有广泛应用。在这个版本中，包含了多个核心组件的源代码文件，如： 1. `./src/agg_renderer.os`：可能是用于agg渲染器的接口或实现，它可能涉及到2D矢量图形的生成和渲染。 2. `./agg/src` 和 `./agg/include`：agg库的源代码和头文件，libagg是一个高性能的2D矢量图形库，提供了各种绘图功能，如路径绘制、图像滤镜和渲染。 3. `./src/graphics.os`, `./src/font_set.os`, `./src/font_engine_freetype.os`：与图形和字体处理相关的模块，可能涉及字体渲染和选择，以及图形符号和图标管理。 4. `./bindings/python` 目录下的多个文件：这些是Mapnik（一个开源GIS库）的Python绑定，用于将Mapnik的功能整合到Python应用中，如符号化、变换处理、图像操作和数据源缓存。 5. `./plugins` 目录下的输入模块：包括shapefile和raster（如shape和栅格数据源）输入模块，用于处理几何数据和栅格数据。 6. `./agg_src` 中的具体对象文件，如`agg_line_aa_basics.o`和`agg_bezier_arc.o`，这些都是编译后的中间文件，用于实现特定的图形算法和效果。 7. `./src/save_map.os` 和 `./src/save_map.os`：可能涉及到地图的保存和输出功能，可能是生成地图图像或者导出数据。 8. `./bindings/python/mapnik_*os` 文件：展示了Python API的不同部分，如规则处理、视图变换、图像操作和数据集等。 9. `./src/color.os`, `./src/stroke.os`, `./src/image_util.os`：颜色处理、描边功能以及图像处理相关的核心函数。 10. `./agg/libagg.a`：libagg库的静态链接文件，用于在编译时包含库的功能。 11. `./plugins/input/shape/dbffile.os` 和 `./plugins/input/raster/raster.input`：针对不同格式的数据源支持，如Shapefile数据库和栅格数据。 12. `./agg/src/agg_vcgen_contour.o` 和 `./agg/src/agg_trans_warp_`：可能与轮廓生成和图像扭曲这样的高级图形操作有关。 Scons V3.0.5 的关键特点是它的灵活性和可扩展性，能适应复杂的构建需求，同时提供了良好的跨平台支持。通过这个版本，开发者可以方便地构建和优化他们的图形应用，尤其是在GIS和地图制作领域。

Cleaning Up After a Build

Java('classes', 'src')

If the src directory contains a single hello.java file, then the output from running the scons command would

look something like this (on a POSIX system):

% scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

javac -d classes -sourcepath src src/hello.java

scons: done building targets.

We'll cover Java builds in more detail, including building Java archive (.jar) and other types of file, in Chapter 26,

Java Builds.

2.4. Cleaning Up After a Build

When using SCons, it is unnecessary to add special commands or target names to clean up after a build. Instead, you

simply use the -c or --clean option when you invoke SCons, and SCons removes the appropriate built files. So if

we build our example above and then invoke scons -c afterwards, the output on POSIX looks like:

% scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cc -o hello.o -c hello.c

cc -o hello hello.o

scons: done building targets.

% scons -c

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Cleaning targets ...

Removed hello.o

Removed hello

scons: done cleaning targets.

And the output on Windows looks like:

C:\>scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cl /Fohello.obj /c hello.c /nologo

link /nologo /OUT:hello.exe hello.obj

embedManifestExeCheck(target, source, env)

scons: done building targets.

C:\>scons -c

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Cleaning targets ...

Removed hello.obj

Removed hello.exe

The SConstruct File

scons: done cleaning targets.

Notice that SCons changes its output to tell you that it is Cleaning targets ... and done cleaning

targets.

2.5. The SConstruct File

If you're used to build systems like Make you've already figured out that the SConstruct file is the SCons equivalent

of a Makefile. That is, the SConstruct file is the input file that SCons reads to control the build.

2.5.1. SConstruct Files Are Python Scripts

There is, however, an important difference between an SConstruct file and a Makefile: the SConstruct file

is actually a Python script. If you're not already familiar with Python, don't worry. This User's Guide will introduce

you step-by-step to the relatively small amount of Python you'll need to know to be able to use SCons effectively.

And Python is very easy to learn.

One aspect of using Python as the scripting language is that you can put comments in your SConstruct file using

Python's commenting convention; that is, everything between a '#' and the end of the line will be ignored:

# Arrange to build the "hello" program.

Program('hello.c') # "hello.c" is the source file.

You'll see throughout the remainder of this Guide that being able to use the power of a real scripting language can

greatly simplify the solutions to complex requirements of real-world builds.

2.5.2. SCons Functions Are Order-Independent

One important way in which the SConstruct file is not exactly like a normal Python script, and is more like a

Makefile, is that the order in which the SCons functions are called in the SConstruct file does not affect the

order in which SCons actually builds the programs and object files you want it to build.

In other words, when you

call the Program builder (or any other builder method), you're not telling SCons to build the program at the instant

the builder method is called. Instead, you're telling SCons to build the program that you want, for example, a program

built from a file named hello.c, and it's up to SCons to build that program (and any other files) whenever it's

necessary. (We'll learn more about how SCons decides when building or rebuilding a file is necessary in Chapter 6,

Dependencies, below.)

SCons reflects this distinction between calling a builder method like Program and actually building the program

by printing the status messages that indicate when it's "just reading" the SConstruct file, and when it's actually

building the target files. This is to make it clear when SCons is executing the Python statements that make up the

SConstruct file, and when SCons is actually executing the commands or other actions to build the necessary files.

Let's clarify this with an example. Python has a print statement that prints a string of characters to the screen. If we

put print statements around our calls to the Program builder method:

print("Calling Program('hello.c')")

Program('hello.c')

print("Calling Program('goodbye.c')")

In programming parlance, the SConstruct file is declarative, meaning you tell SCons what you want done and let it figure out the order in

which to do it, rather than strictly imperative, where you specify explicitly the order in which to do things.

Making the SCons Output Less Verbose

Program('goodbye.c')

print("Finished calling Program()")

Then when we execute SCons, we see the output from the print statements in between the messages about reading

the SConscript files, indicating that that is when the Python statements are being executed:

% scons

scons: Reading SConscript files ...

Calling Program('hello.c')

Calling Program('goodbye.c')

Finished calling Program()

scons: done reading SConscript files.

scons: Building targets ...

cc -o goodbye.o -c goodbye.c

cc -o goodbye goodbye.o

cc -o hello.o -c hello.c

cc -o hello hello.o

scons: done building targets.

Notice also that SCons built the goodbye program first, even though the "reading SConscript" output shows that

we called Program('hello.c') first in the SConstruct file.

2.6. Making the SCons Output Less Verbose

You've already seen how SCons prints some messages about what it's doing, surrounding the actual commands used

to build the software:

C:\>scons

scons: Reading SConscript files ...

scons: done reading SConscript files.

scons: Building targets ...

cl /Fohello.obj /c hello.c /nologo

link /nologo /OUT:hello.exe hello.obj

embedManifestExeCheck(target, source, env)

scons: done building targets.

These messages emphasize the order in which SCons does its work: all of the configuration files (generically referred

to as SConscript files) are read and executed first, and only then are the target files built. Among other benefits,

these messages help to distinguish between errors that occur while the configuration files are read, and errors that

occur while targets are being built.

One drawback, of course, is that these messages clutter the output. Fortunately, they're easily disabled by using the

-Q option when invoking SCons:

C:\>scons -Q

cl /Fohello.obj /c hello.c /nologo

link /nologo /OUT:hello.exe hello.obj

embedManifestExeCheck(target, source, env)

Because we want this User's Guide to focus on what SCons is actually doing, we're going to use the -Q option to

remove these messages from the output of all the remaining examples in this Guide.

Compiling Multiple Source Files

link /nologo /OUT:new_hello.exe hello.obj

embedManifestExeCheck(target, source, env)

3.2. Compiling Multiple Source Files

You've just seen how to configure SCons to compile a program from a single source file. It's more common, of course,

that you'll need to build a program from many input source files, not just one. To do this, you need to put the source

files in a Python list (enclosed in square brackets), like so:

Program(['prog.c', 'file1.c', 'file2.c'])

A build of the above example would look like:

% scons -Q

cc -o file1.o -c file1.c

cc -o file2.o -c file2.c

cc -o prog.o -c prog.c

cc -o prog prog.o file1.o file2.o

Notice that SCons deduces the output program name from the first source file specified in the list--that is, because the

first source file was prog.c, SCons will name the resulting program prog (or prog.exe on a Windows system). If

you want to specify a different program name, then (as we've seen in the previous section) you slide the list of source

files over to the right to make room for the output program file name. (SCons puts the output file name to the left

of the source file names so that the order mimics that of an assignment statement: "program = source files".) This

makes our example:

Program('program', ['prog.c', 'file1.c', 'file2.c'])

On Linux, a build of this example would look like:

% scons -Q

cc -o file1.o -c file1.c

cc -o file2.o -c file2.c

cc -o prog.o -c prog.c

cc -o program prog.o file1.o file2.o

Or on Windows:

C:\>scons -Q

cl /Fofile1.obj /c file1.c /nologo

cl /Fofile2.obj /c file2.c /nologo

cl /Foprog.obj /c prog.c /nologo

link /nologo /OUT:program.exe prog.obj file1.obj file2.obj

embedManifestExeCheck(target, source, env)

3.3. Making a list of files with Glob

You can also use the Glob function to find all files matching a certain template, using the standard shell pattern

matching characters *, ? and [abc] to match any of a, b or c. [!abc] is also supported, to match any character

except a, b or c. This makes many multi-source-file builds quite easy:

剩余313页未读，继续阅读

脱命散人

粉丝: 10
资源: 54

Scons V3.0.5：Mapnik符号化引擎与agg库升级

SCons v4.1.0 - Python编译管理工具更新

scons v3.0.4 完整用户指南（附英文书签）

SCons v4.3.0：新一代基于Python的编译管理工具

scons-3.0.5.zip

SCons v4.1.0 版本

scons v3.0.4 用户指南（带书签！）

Scons用户手册V4.3.0

scons3.0.1 scons-man

scons3.0.1 scons-design

scons3.0.1 scons-api

最新资源