Merged changes in the trunk up to revision 55357.
authorTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Mon, 18 Mar 2013 00:48:59 +0000 (00:48 +0000)
committerTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Mon, 18 Mar 2013 00:48:59 +0000 (00:48 +0000)
Resolved conflicts:
release/datafiles/startup.blend
source/blender/editors/space_nla/nla_buttons.c

Also updated source/blender/blenkernel/intern/linestyle.c as a follow-up of
recent changes for the use of bool.

733 files changed:
CMakeLists.txt
SConstruct
build_files/scons/config/darwin-config.py
build_files/scons/config/freebsd7-config.py
build_files/scons/config/freebsd8-config.py
build_files/scons/config/freebsd9-config.py
build_files/scons/config/linux-config.py
build_files/scons/config/linuxcross-config.py
build_files/scons/config/win32-mingw-config.py
build_files/scons/config/win32-vc-config.py
build_files/scons/config/win64-mingw-config.py
build_files/scons/config/win64-vc-config.py
build_files/scons/tools/Blender.py
build_files/scons/tools/btools.py
doc/python_api/sphinx_doc_gen.py
extern/libmv/third_party/ceres/mkfiles.sh [changed mode: 0755->0644]
intern/cycles/blender/addon/ui.py
release/bin/blender-softwaregl [changed mode: 0755->0644]
release/datafiles/startup.blend
release/scripts/freestyle/data/env_map/brown00.png [new file with mode: 0644]
release/scripts/freestyle/data/env_map/gray00.png [new file with mode: 0644]
release/scripts/freestyle/data/env_map/gray01.png [new file with mode: 0644]
release/scripts/freestyle/data/env_map/gray02.png [new file with mode: 0644]
release/scripts/freestyle/data/env_map/gray03.png [new file with mode: 0644]
release/scripts/freestyle/style_modules/ChainingIterators.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/Functions0D.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/Functions1D.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/PredicatesB1D.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/PredicatesU0D.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/PredicatesU1D.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/anisotropic_diffusion.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/apriori_and_causal_density.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/apriori_density.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/backbone_stretcher.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/blueprint_circles.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/blueprint_ellipses.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/blueprint_squares.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/cartoon.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/contour.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/curvature2d.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/external_contour.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/external_contour_sketchy.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/external_contour_smooth.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/haloing.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/ignore_small_occlusions.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/invisible_lines.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/japanese_bigbrush.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/logical_operators.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/long_anisotropically_dense.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/multiple_parameterization.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/nature.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/near_lines.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/occluded_by_specific_object.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/parameter_editor.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/polygonalize.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/qi0.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/qi0_not_external_contour.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/qi1.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/qi2.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/sequentialsplit_sketchy.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/shaders.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/sketchy_multiple_parameterization.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/sketchy_topology_broken.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/sketchy_topology_preserved.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/split_at_highest_2d_curvatures.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/split_at_tvertices.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/stroke_texture.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/suggestive.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/thickness_fof_depth_discontinuity.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/tipremover.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/tvertex_remover.py [new file with mode: 0644]
release/scripts/freestyle/style_modules/uniformpruning_zsort.py [new file with mode: 0644]
release/scripts/startup/bl_operators/__init__.py
release/scripts/startup/bl_operators/freestyle.py [new file with mode: 0644]
release/scripts/startup/bl_ui/__init__.py
release/scripts/startup/bl_ui/properties_render.py
release/scripts/startup/bl_ui/properties_render_layer.py [new file with mode: 0644]
release/scripts/startup/bl_ui/space_view3d.py
source/blender/CMakeLists.txt
source/blender/SConscript
source/blender/blenfont/BLF_translation.h
source/blender/blenfont/CMakeLists.txt
source/blender/blenfont/SConscript
source/blender/blenkernel/BKE_global.h
source/blender/blenkernel/BKE_linestyle.h [new file with mode: 0644]
source/blender/blenkernel/BKE_main.h
source/blender/blenkernel/CMakeLists.txt
source/blender/blenkernel/SConscript
source/blender/blenkernel/intern/anim_sys.c
source/blender/blenkernel/intern/bpath.c
source/blender/blenkernel/intern/customdata.c
source/blender/blenkernel/intern/group.c
source/blender/blenkernel/intern/idcode.c
source/blender/blenkernel/intern/library.c
source/blender/blenkernel/intern/linestyle.c [new file with mode: 0644]
source/blender/blenkernel/intern/material.c
source/blender/blenkernel/intern/object.c
source/blender/blenkernel/intern/scene.c
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/blenlib/CMakeLists.txt
source/blender/blenlib/SConscript
source/blender/blenloader/CMakeLists.txt
source/blender/blenloader/SConscript
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/bmesh/CMakeLists.txt
source/blender/bmesh/SConscript
source/blender/bmesh/intern/bmesh_mesh_conv.c
source/blender/bmesh/intern/bmesh_operators.h
source/blender/bmesh/operators/bmo_similar.c
source/blender/editors/animation/CMakeLists.txt
source/blender/editors/animation/SConscript
source/blender/editors/animation/anim_channels_defines.c
source/blender/editors/animation/anim_channels_edit.c
source/blender/editors/animation/anim_filter.c
source/blender/editors/include/ED_anim_api.h
source/blender/editors/include/UI_resources.h
source/blender/editors/interface/CMakeLists.txt
source/blender/editors/interface/SConscript
source/blender/editors/interface/interface_templates.c
source/blender/editors/interface/resources.c
source/blender/editors/mesh/CMakeLists.txt
source/blender/editors/mesh/SConscript
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/editors/mesh/mesh_intern.h
source/blender/editors/mesh/mesh_ops.c
source/blender/editors/render/CMakeLists.txt
source/blender/editors/render/SConscript
source/blender/editors/render/render_intern.h
source/blender/editors/render/render_ops.c
source/blender/editors/render/render_shading.c
source/blender/editors/space_buttons/CMakeLists.txt
source/blender/editors/space_buttons/SConscript
source/blender/editors/space_buttons/buttons_context.c
source/blender/editors/space_buttons/buttons_header.c
source/blender/editors/space_buttons/space_buttons.c
source/blender/editors/space_file/CMakeLists.txt
source/blender/editors/space_file/SConscript
source/blender/editors/space_file/filelist.c
source/blender/editors/space_nla/CMakeLists.txt
source/blender/editors/space_nla/SConscript
source/blender/editors/space_nla/nla_buttons.c
source/blender/editors/space_nla/nla_channels.c
source/blender/editors/space_view3d/CMakeLists.txt
source/blender/editors/space_view3d/SConscript
source/blender/editors/space_view3d/drawobject.c
source/blender/freestyle/CMakeLists.txt [new file with mode: 0644]
source/blender/freestyle/FRS_freestyle.h [new file with mode: 0644]
source/blender/freestyle/FRS_freestyle_config.h [new file with mode: 0644]
source/blender/freestyle/SConscript [new file with mode: 0644]
source/blender/freestyle/intern/application/AppCanvas.cpp [new file with mode: 0644]
source/blender/freestyle/intern/application/AppCanvas.h [new file with mode: 0644]
source/blender/freestyle/intern/application/AppConfig.cpp [new file with mode: 0644]
source/blender/freestyle/intern/application/AppConfig.h [new file with mode: 0644]
source/blender/freestyle/intern/application/AppView.cpp [new file with mode: 0644]
source/blender/freestyle/intern/application/AppView.h [new file with mode: 0644]
source/blender/freestyle/intern/application/Controller.cpp [new file with mode: 0644]
source/blender/freestyle/intern/application/Controller.h [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/BlenderFileLoader.h [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.h [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/BlenderStyleModule.h [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/BlenderTextureManager.cpp [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/BlenderTextureManager.h [new file with mode: 0644]
source/blender/freestyle/intern/blender_interface/FRS_freestyle.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/BBox.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Bezier.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Bezier.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/FastGrid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/FastGrid.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/FitCurve.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/FitCurve.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Geom.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/GeomCleaner.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/GeomCleaner.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/GeomUtils.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/GeomUtils.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Grid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Grid.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/GridHelpers.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/GridHelpers.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/HashGrid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/HashGrid.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Noise.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Noise.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/Polygon.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/SweepLine.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/VecMat.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/matrix_util.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/matrix_util.h [new file with mode: 0644]
source/blender/freestyle/intern/geometry/normal_cycle.cpp [new file with mode: 0644]
source/blender/freestyle/intern/geometry/normal_cycle.h [new file with mode: 0644]
source/blender/freestyle/intern/image/GaussianFilter.cpp [new file with mode: 0644]
source/blender/freestyle/intern/image/GaussianFilter.h [new file with mode: 0644]
source/blender/freestyle/intern/image/Image.h [new file with mode: 0644]
source/blender/freestyle/intern/image/ImagePyramid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/image/ImagePyramid.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_BBox.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_BBox.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_BinaryPredicate0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_BinaryPredicate0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_BinaryPredicate1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_BinaryPredicate1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_ContextFunctions.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_ContextFunctions.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Convert.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Convert.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Freestyle.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Freestyle.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_FrsMaterial.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_FrsNoise.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_FrsNoise.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Id.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Id.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_IntegrationType.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_IntegrationType.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Interface0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Interface0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Interface1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Interface1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Iterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Iterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_MediumType.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_MediumType.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Nature.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Nature.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Operators.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_Operators.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_SShape.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_SShape.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_StrokeAttribute.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_StrokeAttribute.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_StrokeShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_StrokeShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryFunction0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryFunction0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryFunction1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryFunction1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryPredicate0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_UnaryPredicate1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_ViewMap.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_ViewMap.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_ViewShape.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BPy_ViewShape.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_FalseBP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_FalseBP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_Length2DBP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_Length2DBP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_SameShapeIdBP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_SameShapeIdBP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_TrueBP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_TrueBP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_ViewMapGradientNormBP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/BinaryPredicate1D/BPy_ViewMapGradientNormBP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Director.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Director.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/BPy_CurvePoint.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/BPy_SVertex.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/BPy_ViewVertex.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/CurvePoint/BPy_StrokeVertex.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_NonTVertex.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface0D/ViewVertex/BPy_TVertex.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_FEdge.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_FrsCurve.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_Stroke.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/BPy_ViewEdge.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/Curve/BPy_Chain.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_AdjacencyIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ChainPredicateIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ChainPredicateIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ChainSilhouetteIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ChainSilhouetteIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ChainingIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_CurvePointIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_CurvePointIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_Interface0DIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_SVertexIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_StrokeVertexIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_ViewEdgeIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_orientedViewEdgeIterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/Iterator/BPy_orientedViewEdgeIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_BackboneStretcherShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_BackboneStretcherShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_BezierCurveShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_BezierCurveShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_CalligraphicShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_CalligraphicShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ColorNoiseShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ColorNoiseShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ColorVariationPatternShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ColorVariationPatternShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstantColorShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstantColorShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstantThicknessShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstantThicknessShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstrainedIncreasingThicknessShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ConstrainedIncreasingThicknessShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_GuidingLinesShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_GuidingLinesShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_IncreasingColorShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_IncreasingColorShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_IncreasingThicknessShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_IncreasingThicknessShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_PolygonalizationShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_PolygonalizationShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_SamplingShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_SamplingShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_SmoothingShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_SpatialNoiseShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_SpatialNoiseShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_StrokeTextureShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_TextureAssignerShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_TextureAssignerShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ThicknessNoiseShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ThicknessNoiseShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ThicknessVariationPatternShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_ThicknessVariationPatternShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_TipRemoverShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_TipRemoverShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_fstreamShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_fstreamShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_streamShader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/StrokeShader/BPy_streamShader.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DDouble.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DDouble.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DEdgeNature.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DEdgeNature.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DFloat.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DFloat.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DId.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DId.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DMaterial.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DMaterial.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DUnsigned.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DUnsigned.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVec2f.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVec2f.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVec3f.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVec3f.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DVectorViewShape.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DViewShape.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DViewShape.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Id/BPy_ShapeIdF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Id/BPy_ShapeIdF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Material/BPy_MaterialF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Material/BPy_MaterialF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Nature_EdgeNature/BPy_CurveNatureF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Nature_EdgeNature/BPy_CurveNatureF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_Normal2DF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_Normal2DF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_VertexOrientation2DF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec2f/BPy_VertexOrientation2DF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/BPy_VertexOrientation3DF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_Vec3f/BPy_VertexOrientation3DF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetOccludeeF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetOccludeeF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetShapeF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_ViewShape/BPy_GetShapeF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_Curvature2DAngleF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_Curvature2DAngleF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_DensityF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_DensityF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedXF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedXF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedYF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedYF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedZF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetProjectedZF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetXF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetXF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetYF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetYF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetZF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_GetZF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_LocalAverageDepthF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_LocalAverageDepthF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_ZDiscontinuityF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_double/BPy_ZDiscontinuityF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetCurvilinearAbscissaF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetCurvilinearAbscissaF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetParameterF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetParameterF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetViewMapGradientNormF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_GetViewMapGradientNormF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadCompleteViewMapPixelF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadCompleteViewMapPixelF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadMapPixelF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadMapPixelF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadSteerableViewMapPixelF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_float/BPy_ReadSteerableViewMapPixelF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_unsigned_int/BPy_QuantitativeInvisibilityF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_unsigned_int/BPy_QuantitativeInvisibilityF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_vector_ViewShape/BPy_GetOccludersF0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction0D/UnaryFunction0D_vector_ViewShape/BPy_GetOccludersF0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DDouble.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DEdgeNature.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DFloat.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DUnsigned.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec2f.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVec3f.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVectorViewShape.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/BPy_UnaryFunction1DVoid.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Nature_EdgeNature/BPy_CurveNatureF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Normal2DF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec2f/BPy_Orientation2DF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_Vec3f/BPy_Orientation3DF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_Curvature2DAngleF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_DensityF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetCompleteViewMapDensityF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetDirectionalViewMapDensityF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedXF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedYF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetProjectedZF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetSteerableViewMapDensityF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetViewMapGradientNormF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetXF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetYF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_GetZF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_LocalAverageDepthF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_double/BPy_ZDiscontinuityF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_unsigned_int/BPy_QuantitativeInvisibilityF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludeeF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetOccludersF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_vector_ViewShape/BPy_GetShapeF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_ChainingTimeStampF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_IncrementChainingTimeStampF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryFunction1D/UnaryFunction1D_void/BPy_TimeStampF1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate0D/BPy_FalseUP0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate0D/BPy_FalseUP0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate0D/BPy_TrueUP0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate0D/BPy_TrueUP0D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_ContourUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_ContourUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_DensityLowerThanUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_DensityLowerThanUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_EqualToChainingTimeStampUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_EqualToChainingTimeStampUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_EqualToTimeStampUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_EqualToTimeStampUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_ExternalContourUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_ExternalContourUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_FalseUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_FalseUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_QuantitativeInvisibilityUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_QuantitativeInvisibilityUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_ShapeUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_ShapeUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_TrueUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_TrueUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_WithinImageBoundaryUP1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/python/UnaryPredicate1D/BPy_WithinImageBoundaryUP1D.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/DrawingStyle.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/FrsMaterial.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/IndexedFaceSet.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/LineRep.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/LineRep.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/Node.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeCamera.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeCamera.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeDrawingStyle.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeGroup.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeGroup.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeLight.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeLight.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeShape.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeShape.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeTransform.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/NodeTransform.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/OrientedLineRep.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/OrientedLineRep.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/Rep.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/Rep.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/ScenePrettyPrinter.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/SceneVisitor.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/SceneVisitor.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/TriangleRep.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/TriangleRep.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/VertexRep.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/VertexRep.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/AdvancedFunctions0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/AdvancedFunctions0D.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/AdvancedFunctions1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/AdvancedFunctions1D.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/AdvancedPredicates1D.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/AdvancedStrokeShaders.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/BasicStrokeShaders.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/BasicStrokeShaders.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Canvas.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Canvas.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Chain.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Chain.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/ChainingIterators.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/ChainingIterators.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/ContextFunctions.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/ContextFunctions.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Curve.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Curve.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/CurveAdvancedIterators.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/CurveIterators.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Modifiers.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Module.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Operators.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Operators.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/PSStrokeRenderer.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/PSStrokeRenderer.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Predicates0D.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Predicates1D.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/QInformationMap.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Stroke.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/Stroke.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeAdvancedIterators.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeIO.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeIO.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeIterators.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeLayer.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeLayer.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeRenderer.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeRenderer.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeRep.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeRep.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeShader.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeTesselator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StrokeTesselator.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/StyleModule.h [new file with mode: 0644]
source/blender/freestyle/intern/stroke/TextStrokeRenderer.cpp [new file with mode: 0644]
source/blender/freestyle/intern/stroke/TextStrokeRenderer.h [new file with mode: 0644]
source/blender/freestyle/intern/system/BaseIterator.h [new file with mode: 0644]
source/blender/freestyle/intern/system/BaseObject.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/BaseObject.h [new file with mode: 0644]
source/blender/freestyle/intern/system/Cast.h [new file with mode: 0644]
source/blender/freestyle/intern/system/Exception.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/Exception.h [new file with mode: 0644]
source/blender/freestyle/intern/system/FreestyleConfig.h [new file with mode: 0644]
source/blender/freestyle/intern/system/Id.h [new file with mode: 0644]
source/blender/freestyle/intern/system/Interpreter.h [new file with mode: 0644]
source/blender/freestyle/intern/system/Iterator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/Iterator.h [new file with mode: 0644]
source/blender/freestyle/intern/system/PointerSequence.h [new file with mode: 0644]
source/blender/freestyle/intern/system/Precision.h [new file with mode: 0644]
source/blender/freestyle/intern/system/ProgressBar.h [new file with mode: 0644]
source/blender/freestyle/intern/system/PseudoNoise.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/PseudoNoise.h [new file with mode: 0644]
source/blender/freestyle/intern/system/PythonInterpreter.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/PythonInterpreter.h [new file with mode: 0644]
source/blender/freestyle/intern/system/RandGen.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/RandGen.h [new file with mode: 0644]
source/blender/freestyle/intern/system/RenderMonitor.h [new file with mode: 0644]
source/blender/freestyle/intern/system/StringUtils.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/StringUtils.h [new file with mode: 0644]
source/blender/freestyle/intern/system/TimeStamp.cpp [new file with mode: 0644]
source/blender/freestyle/intern/system/TimeStamp.h [new file with mode: 0644]
source/blender/freestyle/intern/system/TimeUtils.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ArbitraryGridDensityProvider.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ArbitraryGridDensityProvider.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/AverageAreaGridDensityProvider.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/AverageAreaGridDensityProvider.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/BoxGrid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/BoxGrid.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/CulledOccluderSource.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/CulledOccluderSource.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/FEdgeXDetector.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/FEdgeXDetector.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Functions0D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Functions0D.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Functions1D.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Functions1D.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/GridDensityProvider.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/HeuristicGridDensityProviderFactory.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/HeuristicGridDensityProviderFactory.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Interface0D.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Interface1D.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/OccluderSource.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/OccluderSource.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Pow23GridDensityProvider.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Pow23GridDensityProvider.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Silhouette.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/Silhouette.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/SilhouetteGeomEngine.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/SphericalGrid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/SphericalGrid.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/SteerableViewMap.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/SteerableViewMap.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMap.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMap.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapAdvancedIterators.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapBuilder.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapIO.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapIO.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapIterators.h [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapTesselator.cpp [new file with mode: 0644]
source/blender/freestyle/intern/view_map/ViewMapTesselator.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/Curvature.cpp [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/Curvature.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/Nature.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WEdge.cpp [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WEdge.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WFillGrid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WFillGrid.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WSFillGrid.cpp [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WSFillGrid.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WXEdge.cpp [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WXEdge.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.cpp [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WXEdgeBuilder.h [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.cpp [new file with mode: 0644]
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.h [new file with mode: 0644]
source/blender/makesdna/CMakeLists.txt
source/blender/makesdna/DNA_ID.h
source/blender/makesdna/DNA_action_types.h
source/blender/makesdna/DNA_customdata_types.h
source/blender/makesdna/DNA_freestyle_types.h [new file with mode: 0644]
source/blender/makesdna/DNA_linestyle_types.h [new file with mode: 0644]
source/blender/makesdna/DNA_material_types.h
source/blender/makesdna/DNA_mesh_types.h
source/blender/makesdna/DNA_meshdata_types.h
source/blender/makesdna/DNA_scene_types.h
source/blender/makesdna/DNA_space_types.h
source/blender/makesdna/DNA_userdef_types.h
source/blender/makesdna/SConscript
source/blender/makesdna/intern/CMakeLists.txt
source/blender/makesdna/intern/SConscript
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/RNA_access.h
source/blender/makesrna/RNA_enum_types.h
source/blender/makesrna/SConscript
source/blender/makesrna/intern/CMakeLists.txt
source/blender/makesrna/intern/SConscript
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_ID.c
source/blender/makesrna/intern/rna_action.c
source/blender/makesrna/intern/rna_color.c
source/blender/makesrna/intern/rna_internal.h
source/blender/makesrna/intern/rna_linestyle.c [new file with mode: 0644]
source/blender/makesrna/intern/rna_main.c
source/blender/makesrna/intern/rna_main_api.c
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_space.c
source/blender/makesrna/intern/rna_userdef.c
source/blender/python/SConscript
source/blender/python/bmesh/bmesh_py_types.c
source/blender/python/bmesh/bmesh_py_types_customdata.c
source/blender/python/intern/CMakeLists.txt
source/blender/python/intern/bpy.c
source/blender/python/intern/bpy_app.c
source/blender/python/intern/bpy_app_build_options.c
source/blender/render/CMakeLists.txt
source/blender/render/SConscript
source/blender/render/extern/include/RE_pipeline.h
source/blender/render/intern/include/render_types.h
source/blender/render/intern/source/convertblender.c
source/blender/render/intern/source/pipeline.c
source/blender/render/intern/source/render_result.c
source/blender/render/intern/source/shadeoutput.c
source/blender/windowmanager/CMakeLists.txt
source/blender/windowmanager/SConscript
source/blender/windowmanager/WM_types.h
source/blender/windowmanager/intern/wm_files.c
source/blenderplayer/bad_level_call_stubs/CMakeLists.txt
source/blenderplayer/bad_level_call_stubs/SConscript
source/blenderplayer/bad_level_call_stubs/stubs.c
source/creator/CMakeLists.txt
source/creator/creator.c

index 005de70..579f474 100644 (file)
@@ -237,6 +237,9 @@ option(WITH_LZMA          "Enable best LZMA compression, (used for pointcache)"
 # Camera/motion tracking
 option(WITH_LIBMV         "Enable libmv structure from motion library" ON)
 
+# Freestyle
+option(WITH_FREESTYLE     "Enable Freestyle (advanced edges rendering)" ON)
+
 # Misc
 option(WITH_INPUT_NDOF "Enable NDOF input devices (SpaceNavigator and friends)" ON)
 option(WITH_RAYOPTIMIZATION    "Enable use of SIMD (SSE) optimizations for the raytracer" ON)
index e9ffab4..2027ac5 100644 (file)
@@ -269,6 +269,7 @@ if 'blenderlite' in B.targets:
     target_env_defs['WITH_BF_PYTHON'] = False
     target_env_defs['WITH_BF_3DMOUSE'] = False
     target_env_defs['WITH_BF_LIBMV'] = False
+    target_env_defs['WITH_BF_FREESTYLE'] = False
 
     # Merge blenderlite, let command line to override
     for k,v in target_env_defs.iteritems():
@@ -712,6 +713,10 @@ if env['OURPLATFORM']!='darwin':
                 if VERSION_RELEASE_CYCLE == "release" and "addons_contrib" in dn:
                     dn.remove('addons_contrib')
 
+                # do not install freestyle if disabled
+                if not env['WITH_BF_FREESTYLE'] and "freestyle" in dn:
+                    dn.remove("freestyle")
+
                 dir = os.path.join(env['BF_INSTALLDIR'], VERSION)
                 dir += os.sep + os.path.basename(scriptpath) + dp[len(scriptpath):]
 
index 267505b..0e41371 100644 (file)
@@ -317,6 +317,9 @@ WITH_BF_CYCLES_CUDA_BINARIES = False
 BF_CYCLES_CUDA_NVCC = '/usr/local/cuda/bin/nvcc'
 BF_CYCLES_CUDA_BINARIES_ARCH = ['sm_20', 'sm_21', 'sm_30']
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 #Ray trace optimization
 if MACOSX_ARCHITECTURE == 'x86_64' or MACOSX_ARCHITECTURE == 'i386':
     WITH_BF_RAYOPTIMIZATION = True
index 02c9093..6c39039 100644 (file)
@@ -162,6 +162,9 @@ WITH_GHOST_XDND = False
 
 WITH_BF_OPENMP = True
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 #Ray trace optimization
 WITH_BF_RAYOPTIMIZATION = True
 BF_RAYOPTIMIZATION_SSE_FLAGS = ['-msse','-pthread']
index 5d3308c..3318e21 100644 (file)
@@ -162,6 +162,9 @@ WITH_BF_OPENMP = True
 
 WITH_GHOST_XDND = False
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 #Ray trace optimization
 WITH_BF_RAYOPTIMIZATION = True
 BF_RAYOPTIMIZATION_SSE_FLAGS = ['-msse','-pthread']
index 98c2c8f..b6c5c0d 100644 (file)
@@ -162,6 +162,9 @@ WITH_BF_OPENMP = True
 
 WITH_GHOST_XDND = False
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 #Ray trace optimization
 WITH_BF_RAYOPTIMIZATION = True
 BF_RAYOPTIMIZATION_SSE_FLAGS = ['-msse','-pthread']
index bef3472..2aec75e 100644 (file)
@@ -226,6 +226,9 @@ BF_3DMOUSE_LIBPATH = '${BF_3DMOUSE}/lib'
 BF_3DMOUSE_LIB = 'spnav'
 BF_3DMOUSE_LIB_STATIC = '${BF_3DMOUSE_LIBPATH}/libspnav.a'
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 ##
 CC = 'gcc'
 CXX = 'g++'
index 54faf59..925ca5b 100644 (file)
@@ -160,6 +160,9 @@ BF_OPENCOLLADA_INC = '${BF_OPENCOLLADA}/include'
 BF_OPENCOLLADA_LIB = 'OpenCOLLADAStreamWriter OpenCOLLADASaxFrameworkLoader OpenCOLLADAFramework OpenCOLLADABaseUtils GeneratedSaxParser UTF MathMLSolver expat pcre buffer ftoa'
 BF_OPENCOLLADA_LIBPATH = '${BF_OPENCOLLADA}/lib ${BF_ICONV_LIBPATH}'
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 #Ray trace optimization
 WITH_BF_RAYOPTIMIZATION = True
 BF_RAYOPTIMIZATION_SSE_FLAGS = ['-msse']
index b5bcbc9..691a484 100644 (file)
@@ -176,6 +176,9 @@ WITH_BF_CYCLES_CUDA_BINARIES = False
 #BF_CYCLES_CUDA_NVCC = "" # Path to the nvidia compiler
 BF_CYCLES_CUDA_BINARIES_ARCH = ['sm_20', 'sm_21', 'sm_30']
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 ##
 CC = 'gcc'
 CXX = 'g++'
index 8d17c77..5aa1e76 100644 (file)
@@ -195,6 +195,9 @@ BF_CYCLES_CUDA_BINARIES_ARCH = ['sm_20', 'sm_21', 'sm_30']
 WITH_BF_RAYOPTIMIZATION = True
 BF_RAYOPTIMIZATION_SSE_FLAGS = ['/arch:SSE']
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 WITH_BF_STATICOPENGL = False
 BF_OPENGL_INC = '${BF_OPENGL}/include'
 BF_OPENGL_LIBINC = '${BF_OPENGL}/lib'
index 0a604b0..203d63b 100644 (file)
@@ -174,6 +174,9 @@ BF_RAYOPTIMIZATION_SSE_FLAGS = ['-mmmx', '-msse', '-msse2']
 #May produce errors with unsupported MinGW-w64 builds
 WITH_BF_OPENMP = False
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 ##
 CC = 'gcc'
 CXX = 'g++'
index 4e76334..c2f57da 100644 (file)
@@ -192,6 +192,9 @@ WITH_BF_RAYOPTIMIZATION = True
 # No need to manually specify SSE/SSE2 on x64 systems.
 BF_RAYOPTIMIZATION_SSE_FLAGS = ['']
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 WITH_BF_STATICOPENGL = False
 BF_OPENGL_INC = '${BF_OPENGL}/include'
 BF_OPENGL_LIBINC = '${BF_OPENGL}/lib'
index b3c3907..4572ee7 100644 (file)
@@ -391,6 +391,10 @@ def creator(env):
         if env['BF_DEBUG']:
             defs.append('_DEBUG')
 
+    if env['WITH_BF_FREESTYLE']:
+        incs.append('#/source/blender/freestyle')
+        defs.append('WITH_FREESTYLE')
+
     if env['OURPLATFORM'] in ('win32-vc', 'win32-mingw', 'linuxcross', 'win64-vc', 'win64-mingw'):
         incs.append(env['BF_PTHREADS_INC'])
         incs.append('#/intern/utfconv')
index ee6dd20..9a31ba6 100644 (file)
@@ -116,6 +116,7 @@ def validate_arguments(args, bc):
             'WITH_BF_TIFF', 'BF_TIFF', 'BF_TIFF_INC', 'BF_TIFF_LIB', 'BF_TIFF_LIBPATH', 'WITH_BF_STATICTIFF', 'BF_TIFF_LIB_STATIC',
             'WITH_BF_ZLIB', 'BF_ZLIB', 'BF_ZLIB_INC', 'BF_ZLIB_LIB', 'BF_ZLIB_LIBPATH', 'WITH_BF_STATICZLIB', 'BF_ZLIB_LIB_STATIC',
             'WITH_BF_INTERNATIONAL',
+            'WITH_BF_FREESTYLE',
             'WITH_BF_ICONV', 'BF_ICONV', 'BF_ICONV_INC', 'BF_ICONV_LIB', 'BF_ICONV_LIBPATH',
             'WITH_BF_GAMEENGINE',
             'WITH_BF_BULLET', 'BF_BULLET', 'BF_BULLET_INC', 'BF_BULLET_LIB',
@@ -386,6 +387,8 @@ def read_opts(env, cfg, args):
 
         (BoolVariable('WITH_BF_INTERNATIONAL', 'Use Boost::locale if true', True)),
 
+        (BoolVariable('WITH_BF_FREESTYLE', 'Build advanced edge renderer', True)),
+
         (BoolVariable('WITH_BF_ICONV', 'Use iconv if true', True)),
         ('BF_ICONV', 'iconv base path', ''),
         ('BF_ICONV_INC', 'iconv include path', ''),
index 09e844a..72e92e5 100644 (file)
@@ -262,6 +262,7 @@ else:
         "mathutils",
         "mathutils.geometry",
         "mathutils.noise",
+        "Freestyle",
         ]
 
     # ------
@@ -449,6 +450,7 @@ if ARGS.sphinx_build_pdf:
 ClassMethodDescriptorType = type(dict.__dict__['fromkeys'])
 MethodDescriptorType = type(dict.get)
 GetSetDescriptorType = type(int.real)
+StaticMethodType = type(staticmethod(lambda: None))
 from types import MemberDescriptorType
 
 _BPY_STRUCT_FAKE = "bpy_struct"
@@ -915,6 +917,12 @@ def pymodule2sphinx(basepath, module_name, module, title):
             if type(descr) == GetSetDescriptorType:
                 py_descr2sphinx("   ", fw, descr, module_name, type_name, key)
 
+        for key, descr in descr_items:
+            if type(descr) == StaticMethodType:
+                descr = getattr(value, key)
+                write_indented_lines("   ", fw, descr.__doc__ or "Undocumented", False)
+                fw("\n")
+
         fw("\n\n")
 
     file.close()
@@ -1547,7 +1555,7 @@ def write_rst_contents(basepath):
         # mathutils
         "mathutils", "mathutils.geometry", "mathutils.noise",
         # misc
-        "bgl", "blf", "gpu", "aud", "bpy_extras",
+        "Freestyle", "bgl", "blf", "gpu", "aud", "bpy_extras",
         # bmesh, submodules are in own page
         "bmesh",
         )
@@ -1695,6 +1703,7 @@ def write_rst_importable_modules(basepath):
         "mathutils"         : "Math Types & Utilities",
         "mathutils.geometry": "Geometry Utilities",
         "mathutils.noise"   : "Noise Utilities",
+        "Freestyle"         : "Freestyle Data Types & Operators",
     }
     for mod_name, mod_descr in importable_modules.items():
         if mod_name not in EXCLUDE_MODULES:
old mode 100755 (executable)
new mode 100644 (file)
index a8ff861..b928fb0 100644 (file)
@@ -233,10 +233,69 @@ class CyclesRender_PT_performance(CyclesButtonsPanel, Panel):
         sub.prop(rd, "use_persistent_data", text="Persistent Images")
 
 
+class Cycles_PT_post_processing(CyclesButtonsPanel, Panel):
+    bl_label = "Post Processing"
+    bl_options = {'DEFAULT_CLOSED'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        rd = context.scene.render
+
+        split = layout.split()
+
+        col = split.column()
+        col.prop(rd, "use_compositing")
+        col.prop(rd, "use_sequencer")
+
+        col = split.column()
+        col.prop(rd, "dither_intensity", text="Dither", slider=True)
+
+
+class CyclesCamera_PT_dof(CyclesButtonsPanel, Panel):
+    bl_label = "Depth of Field"
+    bl_context = "data"
+
+    @classmethod
+    def poll(cls, context):
+        return context.camera and CyclesButtonsPanel.poll(context)
+
+    def draw(self, context):
+        layout = self.layout
+
+        cam = context.camera
+        ccam = cam.cycles
+
+        split = layout.split()
+
+        col = split.column()
+        col.label("Focus:")
+        col.prop(cam, "dof_object", text="")
+
+        sub = col.row()
+        sub.active = cam.dof_object is None
+        sub.prop(cam, "dof_distance", text="Distance")
+
+        col = split.column()
+
+        col.label("Aperture:")
+        sub = col.column(align=True)
+        sub.prop(ccam, "aperture_type", text="")
+        if ccam.aperture_type == 'RADIUS':
+            sub.prop(ccam, "aperture_size", text="Size")
+        elif ccam.aperture_type == 'FSTOP':
+            sub.prop(ccam, "aperture_fstop", text="Number")
+
+        sub = col.column(align=True)
+        sub.prop(ccam, "aperture_blades", text="Blades")
+        sub.prop(ccam, "aperture_rotation", text="Rotation")
+
+
 class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
     bl_label = "Layers"
-    bl_options = {'DEFAULT_CLOSED'}
-    COMPAT_ENGINES = {'BLENDER_RENDER'}
+    bl_options = {'HIDE_HEADER'}
+    bl_context = "render_layer"
+    COMPAT_ENGINES = {'CYCLES'}
 
     def draw(self, context):
         layout = self.layout
@@ -245,7 +304,7 @@ class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
         rd = scene.render
 
         row = layout.row()
-        row.template_list("RENDER_UL_renderlayers", "", rd, "layers", rd.layers, "active_index", rows=2)
+        row.template_list("RENDERLAYER_UL_renderlayers", "", rd, "layers", rd.layers, "active_index", rows=2)
 
         col = row.column(align=True)
         col.operator("scene.render_layer_add", icon='ZOOMIN', text="")
@@ -253,9 +312,24 @@ class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
 
         row = layout.row()
         rl = rd.layers.active
-        row.prop(rl, "name")
+        if rl:
+            row.prop(rl, "name")
         row.prop(rd, "use_single_layer", text="", icon_only=True)
 
+
+class CyclesRender_PT_layer_options(CyclesButtonsPanel, Panel):
+    bl_label = "Layer"
+    bl_options = {'DEFAULT_CLOSED'}
+    bl_context = "render_layer"
+    COMPAT_ENGINES = {'CYCLES'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        scene = context.scene
+        rd = scene.render
+        rl = rd.layers.active
+
         split = layout.split()
 
         col = split.column()
@@ -277,6 +351,20 @@ class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
         col.prop(rl, "samples")
         col.prop(rl, "use_sky", "Use Environment")
 
+
+class CyclesRender_PT_layer_passes(CyclesButtonsPanel, Panel):
+    bl_label = "Render Passes"
+    bl_options = {'DEFAULT_CLOSED'}
+    bl_context = "render_layer"
+    COMPAT_ENGINES = {'CYCLES'}
+
+    def draw(self, context):
+        layout = self.layout
+
+        scene = context.scene
+        rd = scene.render
+        rl = rd.layers.active
+
         split = layout.split()
 
         col = split.column()
@@ -313,64 +401,6 @@ class CyclesRender_PT_layers(CyclesButtonsPanel, Panel):
         col.prop(rl, "use_pass_environment")
 
 
-class Cycles_PT_post_processing(CyclesButtonsPanel, Panel):
-    bl_label = "Post Processing"
-    bl_options = {'DEFAULT_CLOSED'}
-
-    def draw(self, context):
-        layout = self.layout
-
-        rd = context.scene.render
-
-        split = layout.split()
-
-        col = split.column()
-        col.prop(rd, "use_compositing")
-        col.prop(rd, "use_sequencer")
-
-        col = split.column()
-        col.prop(rd, "dither_intensity", text="Dither", slider=True)
-
-
-class CyclesCamera_PT_dof(CyclesButtonsPanel, Panel):
-    bl_label = "Depth of Field"
-    bl_context = "data"
-
-    @classmethod
-    def poll(cls, context):
-        return context.camera and CyclesButtonsPanel.poll(context)
-
-    def draw(self, context):
-        layout = self.layout
-
-        cam = context.camera
-        ccam = cam.cycles
-
-        split = layout.split()
-
-        col = split.column()
-        col.label("Focus:")
-        col.prop(cam, "dof_object", text="")
-
-        sub = col.row()
-        sub.active = cam.dof_object is None
-        sub.prop(cam, "dof_distance", text="Distance")
-
-        col = split.column()
-
-        col.label("Aperture:")
-        sub = col.column(align=True)
-        sub.prop(ccam, "aperture_type", text="")
-        if ccam.aperture_type == 'RADIUS':
-            sub.prop(ccam, "aperture_size", text="Size")
-        elif ccam.aperture_type == 'FSTOP':
-            sub.prop(ccam, "aperture_fstop", text="Number")
-
-        sub = col.column(align=True)
-        sub.prop(ccam, "aperture_blades", text="Blades")
-        sub.prop(ccam, "aperture_rotation", text="Rotation")
-
-
 class Cycles_PT_context_material(CyclesButtonsPanel, Panel):
     bl_label = ""
     bl_context = "material"
old mode 100755 (executable)
new mode 100644 (file)
index 970a787..63e6d9a
@@ -1,25 +1,25 @@
-#!/bin/sh
-BF_DIST_BIN=`dirname "$0"`
-BF_PROGRAM="blender" # BF_PROGRAM=`basename "$0"`-bin
-exitcode=0
-
-LD_LIBRARY_PATH=${BF_DIST_BIN}/lib:${LD_LIBRARY_PATH}
-
-if [ -n "$LD_LIBRARYN32_PATH" ]; then
-    LD_LIBRARYN32_PATH=${BF_DIST_BIN}/lib:${LD_LIBRARYN32_PATH}
-fi
-if [ -n "$LD_LIBRARYN64_PATH" ]; then
-    LD_LIBRARYN64_PATH=${BF_DIST_BIN}/lib:${LD_LIBRARYN64_PATH}
-fi
-if [ -n "$LD_LIBRARY_PATH_64" ]; then
-    LD_LIBRARY_PATH_64=${BF_DIST_BIN}/lib:${LD_LIBRARY_PATH_64}
-fi
-
-# Workaround for half-transparent windows when compiz is enabled
-XLIB_SKIP_ARGB_VISUALS=1
-
-export LD_LIBRARY_PATH LD_LIBRARYN32_PATH LD_LIBRARYN64_PATH LD_LIBRARY_PATH_64 LD_PRELOAD XLIB_SKIP_ARGB_VISUALS
-
-"$BF_DIST_BIN/$BF_PROGRAM" ${1+"$@"}
-exitcode=$?
-exit $exitcode
+#!/bin/sh\r
+BF_DIST_BIN=`dirname "$0"`\r
+BF_PROGRAM="blender" # BF_PROGRAM=`basename "$0"`-bin\r
+exitcode=0\r
+\r
+LD_LIBRARY_PATH=${BF_DIST_BIN}/lib:${LD_LIBRARY_PATH}\r
+\r
+if [ -n "$LD_LIBRARYN32_PATH" ]; then\r
+    LD_LIBRARYN32_PATH=${BF_DIST_BIN}/lib:${LD_LIBRARYN32_PATH}\r
+fi\r
+if [ -n "$LD_LIBRARYN64_PATH" ]; then\r
+    LD_LIBRARYN64_PATH=${BF_DIST_BIN}/lib:${LD_LIBRARYN64_PATH}\r
+fi\r
+if [ -n "$LD_LIBRARY_PATH_64" ]; then\r
+    LD_LIBRARY_PATH_64=${BF_DIST_BIN}/lib:${LD_LIBRARY_PATH_64}\r
+fi\r
+\r
+# Workaround for half-transparent windows when compiz is enabled\r
+XLIB_SKIP_ARGB_VISUALS=1\r
+\r
+export LD_LIBRARY_PATH LD_LIBRARYN32_PATH LD_LIBRARYN64_PATH LD_LIBRARY_PATH_64 LD_PRELOAD XLIB_SKIP_ARGB_VISUALS\r
+\r
+"$BF_DIST_BIN/$BF_PROGRAM" ${1+"$@"}\r
+exitcode=$?\r
+exit $exitcode\r
index e5d781e..40e1363 100644 (file)
Binary files a/release/datafiles/startup.blend and b/release/datafiles/startup.blend differ
diff --git a/release/scripts/freestyle/data/env_map/brown00.png b/release/scripts/freestyle/data/env_map/brown00.png
new file mode 100644 (file)
index 0000000..855f06f
Binary files /dev/null and b/release/scripts/freestyle/data/env_map/brown00.png differ
diff --git a/release/scripts/freestyle/data/env_map/gray00.png b/release/scripts/freestyle/data/env_map/gray00.png
new file mode 100644 (file)
index 0000000..7c9b1a8
Binary files /dev/null and b/release/scripts/freestyle/data/env_map/gray00.png differ
diff --git a/release/scripts/freestyle/data/env_map/gray01.png b/release/scripts/freestyle/data/env_map/gray01.png
new file mode 100644 (file)
index 0000000..0654290
Binary files /dev/null and b/release/scripts/freestyle/data/env_map/gray01.png differ
diff --git a/release/scripts/freestyle/data/env_map/gray02.png b/release/scripts/freestyle/data/env_map/gray02.png
new file mode 100644 (file)
index 0000000..0208f49
Binary files /dev/null and b/release/scripts/freestyle/data/env_map/gray02.png differ
diff --git a/release/scripts/freestyle/data/env_map/gray03.png b/release/scripts/freestyle/data/env_map/gray03.png
new file mode 100644 (file)
index 0000000..aab9b95
Binary files /dev/null and b/release/scripts/freestyle/data/env_map/gray03.png differ
diff --git a/release/scripts/freestyle/style_modules/ChainingIterators.py b/release/scripts/freestyle/style_modules/ChainingIterators.py
new file mode 100644 (file)
index 0000000..f0dfc46
--- /dev/null
@@ -0,0 +1,703 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : ChainingIterators.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Chaining Iterators to be used with chaining operators
+
+from Freestyle import AdjacencyIterator, ChainingIterator, ExternalContourUP1D, Nature, TVertex
+from Freestyle import ContextFunctions as CF
+
+## the natural chaining iterator
+## It follows the edges of same nature following the topology of
+## objects with  preseance on silhouettes, then borders, 
+## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
+## You can specify whether to stay in the selection or not.
+class pyChainSilhouetteIterator(ChainingIterator):
+       def __init__(self, stayInSelection=True):
+               ChainingIterator.__init__(self, stayInSelection, True, None, True)
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               if ve.id == mateVE.id:
+                                       winner = ve
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for i in range(len(natures)):
+                               currentNature = self.current_edge.nature
+                               if (natures[i] & currentNature) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               visitNext = 0
+                                               oNature = it.object.nature
+                                               if (oNature & natures[i]) != 0:
+                                                       if natures[i] != oNature:
+                                                               for j in range(i):
+                                                                       if (natures[j] & oNature) != 0:
+                                                                               visitNext = 1
+                                                                               break
+                                                               if visitNext != 0:
+                                                                       break    
+                                                       count = count+1
+                                                       winner = it.object
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               return winner
+
+## the natural chaining iterator
+## It follows the edges of same nature on the same
+## objects with  preseance on silhouettes, then borders, 
+## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
+## You can specify whether to stay in the selection or not.
+## You can specify whether to chain iterate over edges that were 
+## already visited or not.
+class pyChainSilhouetteGenericIterator(ChainingIterator):
+       def __init__(self, stayInSelection=True, stayInUnvisited=True):
+               ChainingIterator.__init__(self, stayInSelection, stayInUnvisited, None, True)
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               if ve.id == mateVE.id:
+                                       winner = ve
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for i in range(len(natures)):
+                               currentNature = self.current_edge.nature
+                               if (natures[i] & currentNature) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               visitNext = 0
+                                               oNature = it.object.nature
+                                               ve = it.object
+                                               if ve.id == self.current_edge.id:
+                                                       it.increment()
+                                                       continue
+                                               if (oNature & natures[i]) != 0:
+                                                       if natures[i] != oNature:
+                                                               for j in range(i):
+                                                                       if (natures[j] & oNature) != 0:
+                                                                               visitNext = 1
+                                                                               break
+                                                               if visitNext != 0:
+                                                                       break    
+                                                       count = count+1
+                                                       winner = ve
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               return winner
+                       
+class pyExternalContourChainingIterator(ChainingIterator):
+       def __init__(self):
+               ChainingIterator.__init__(self, False, True, None, True)
+               self._isExternalContour = ExternalContourUP1D()
+       def init(self):
+               self._nEdges = 0
+               self._isInSelection = 1
+       def checkViewEdge(self, ve, orientation):
+               if orientation != 0:
+                       vertex = ve.second_svertex()
+               else:
+                       vertex = ve.first_svertex()
+               it = AdjacencyIterator(vertex,1,1)
+               while not it.is_end:
+                       ave = it.object
+                       if self._isExternalContour(ave):
+                               return 1
+                       it.increment()
+               print("pyExternlContourChainingIterator : didn't find next edge")
+               return 0
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               while not it.is_end:
+                       ve = it.object
+                       if self._isExternalContour(ve):
+                               if ve.time_stamp == CF.get_time_stamp():
+                                       winner = ve
+                       it.increment()
+               
+               self._nEdges = self._nEdges+1
+               if winner is None:
+                       orient = 1
+                       it = AdjacencyIterator(iter)
+                       while not it.is_end:
+                               ve = it.object
+                               if it.is_incoming:
+                                       orient = 0
+                               good = self.checkViewEdge(ve,orient)
+                               if good != 0:
+                                       winner = ve
+                               it.increment()
+               return winner
+
+## the natural chaining iterator
+## with a sketchy multiple touch
+class pySketchyChainSilhouetteIterator(ChainingIterator):
+       def __init__(self, nRounds=3,stayInSelection=True):
+               ChainingIterator.__init__(self, stayInSelection, False, None, True)
+               self._timeStamp = CF.get_time_stamp()+nRounds
+               self._nRounds = nRounds
+       def init(self):
+               self._timeStamp = CF.get_time_stamp()+self._nRounds
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               if ve.id == mateVE.id:
+                                       winner = ve
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for i in range(len(natures)):
+                               currentNature = self.current_edge.nature
+                               if (natures[i] & currentNature) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               visitNext = 0
+                                               oNature = it.object.nature
+                                               ve = it.object
+                                               if ve.id == self.current_edge.id:
+                                                       it.increment()
+                                                       continue
+                                               if (oNature & natures[i]) != 0:
+                                                       if (natures[i] != oNature) != 0:
+                                                               for j in range(i):
+                                                                       if (natures[j] & oNature) != 0:
+                                                                               visitNext = 1
+                                                                               break
+                                                               if visitNext != 0:
+                                                                       break    
+                                                       count = count+1
+                                                       winner = ve
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               if winner is None:
+                       winner = self.current_edge
+               if winner.chaining_time_stamp == self._timeStamp:
+                       winner = None
+               return winner
+
+
+# Chaining iterator designed for sketchy style.
+# can chain several times the same ViewEdge
+# in order to produce multiple strokes per ViewEdge.
+class pySketchyChainingIterator(ChainingIterator):
+       def __init__(self, nRounds=3, stayInSelection=True):
+               ChainingIterator.__init__(self, stayInSelection, False, None, True)
+               self._timeStamp = CF.get_time_stamp()+nRounds
+               self._nRounds = nRounds
+       def init(self):
+               self._timeStamp = CF.get_time_stamp()+self._nRounds
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               while not it.is_end:
+                       ve = it.object
+                       if ve.id == self.current_edge.id:
+                               it.increment()
+                               continue
+                       winner = ve
+                       it.increment()
+               if winner is None:
+                       winner = self.current_edge
+               if winner.chaining_time_stamp == self._timeStamp:
+                       return None
+               return winner
+
+
+## Chaining iterator that fills small occlusions
+##     percent
+##             The max length of the occluded part 
+##             expressed in % of the total chain length
+class pyFillOcclusionsRelativeChainingIterator(ChainingIterator):
+       def __init__(self, percent):
+               ChainingIterator.__init__(self, False, True, None, True)
+               self._length = 0
+               self._percent = float(percent)
+       def init(self):
+               # each time we're evaluating a chain length 
+               # we try to do it once. Thus we reinit 
+               # the chain length here:
+               self._length = 0
+       def traverse(self, iter):
+               winner = None
+               winnerOrientation = 0
+               print(self.current_edge.id.first, self.current_edge.id.second)
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               if ve.id == mateVE.id:
+                                       winner = ve
+                                       if not it.is_incoming:
+                                               winnerOrientation = 1
+                                       else:
+                                               winnerOrientation = 0
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for nat in natures:
+                               if (self.current_edge.nature & nat) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               ve = it.object
+                                               if (ve.nature & nat) != 0:
+                                                       count = count+1
+                                                       winner = ve
+                                                       if not it.is_incoming:
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               if winner is not None:
+                       # check whether this edge was part of the selection
+                       if winner.time_stamp != CF.get_time_stamp():
+                               #print("---", winner.id.first, winner.id.second)
+                               # if not, let's check whether it's short enough with
+                               # respect to the chain made without staying in the selection
+                               #------------------------------------------------------------
+                               # Did we compute the prospective chain length already ?
+                               if self._length == 0:
+                                       #if not, let's do it
+                                       _it = pyChainSilhouetteGenericIterator(0,0)
+                                       _it.begin = winner
+                                       _it.current_edge = winner
+                                       _it.orientation = winnerOrientation
+                                       _it.init()
+                                       while not _it.is_end:
+                                               ve = _it.object
+                                               #print("--------", ve.id.first, ve.id.second)
+                                               self._length = self._length + ve.length_2d
+                                               _it.increment()
+                                               if _it.is_begin:
+                                                       break;
+                                       _it.begin = winner
+                                       _it.current_edge = winner
+                                       _it.orientation = winnerOrientation
+                                       if not _it.is_begin:
+                                               _it.decrement()
+                                               while (not _it.is_end) and (not _it.is_begin):
+                                                       ve = _it.object
+                                                       #print("--------", ve.id.first, ve.id.second)
+                                                       self._length = self._length + ve.length_2d
+                                                       _it.decrement()
+
+                               # let's do the comparison:
+                               # nw let's compute the length of this connex non selected part:
+                               connexl = 0
+                               _cit = pyChainSilhouetteGenericIterator(0,0)
+                               _cit.begin = winner
+                               _cit.current_edge = winner
+                               _cit.orientation = winnerOrientation
+                               _cit.init()
+                               while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():
+                                       ve = _cit.object
+                                       #print("-------- --------", ve.id.first, ve.id.second)
+                                       connexl = connexl + ve.length_2d
+                                       _cit.increment()
+                               if connexl > self._percent * self._length:
+                                       winner = None
+               return winner
+
+## Chaining iterator that fills small occlusions
+##     size
+##             The max length of the occluded part 
+##             expressed in pixels
+class pyFillOcclusionsAbsoluteChainingIterator(ChainingIterator):
+       def __init__(self, length):
+               ChainingIterator.__init__(self, False, True, None, True)
+               self._length = float(length)
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               winnerOrientation = 0
+               #print(self.current_edge.id.first, self.current_edge.id.second)
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               if ve.id == mateVE.id:
+                                       winner = ve
+                                       if not it.is_incoming:
+                                               winnerOrientation = 1
+                                       else:
+                                               winnerOrientation = 0
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for nat in natures:
+                               if (self.current_edge.nature & nat) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               ve = it.object
+                                               if (ve.nature & nat) != 0:
+                                                       count = count+1
+                                                       winner = ve
+                                                       if not it.is_incoming:
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               if winner is not None:
+                       # check whether this edge was part of the selection
+                       if winner.time_stamp != CF.get_time_stamp():
+                               #print("---", winner.id.first, winner.id.second)
+                               # nw let's compute the length of this connex non selected part:
+                               connexl = 0
+                               _cit = pyChainSilhouetteGenericIterator(0,0)
+                               _cit.begin = winner
+                               _cit.current_edge = winner
+                               _cit.orientation = winnerOrientation
+                               _cit.init()
+                               while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():
+                                       ve = _cit.object
+                                       #print("-------- --------", ve.id.first, ve.id.second)
+                                       connexl = connexl + ve.length_2d
+                                       _cit.increment()
+                               if connexl > self._length:
+                                       winner = None
+               return winner
+
+
+## Chaining iterator that fills small occlusions
+##     percent
+##             The max length of the occluded part 
+##             expressed in % of the total chain length
+class pyFillOcclusionsAbsoluteAndRelativeChainingIterator(ChainingIterator):
+       def __init__(self, percent, l):
+               ChainingIterator.__init__(self, False, True, None, True)
+               self._length = 0
+               self._absLength = l
+               self._percent = float(percent)
+       def init(self):
+               # each time we're evaluating a chain length 
+               # we try to do it once. Thus we reinit 
+               # the chain length here:
+               self._length = 0
+       def traverse(self, iter):
+               winner = None
+               winnerOrientation = 0
+               print(self.current_edge.id.first, self.current_edge.id.second)
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               if ve.id == mateVE.id:
+                                       winner = ve
+                                       if not it.is_incoming:
+                                               winnerOrientation = 1
+                                       else:
+                                               winnerOrientation = 0
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for nat in natures:
+                               if (self.current_edge.nature & nat) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               ve = it.object
+                                               if (ve.nature & nat) != 0:
+                                                       count = count+1
+                                                       winner = ve
+                                                       if not it.is_incoming:
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               if winner is not None:
+                       # check whether this edge was part of the selection
+                       if winner.time_stamp != CF.get_time_stamp():
+                               #print("---", winner.id.first, winner.id.second)
+                               # if not, let's check whether it's short enough with
+                               # respect to the chain made without staying in the selection
+                               #------------------------------------------------------------
+                               # Did we compute the prospective chain length already ?
+                               if self._length == 0:
+                                       #if not, let's do it
+                                       _it = pyChainSilhouetteGenericIterator(0,0)
+                                       _it.begin = winner
+                                       _it.current_edge = winner
+                                       _it.orientation = winnerOrientation
+                                       _it.init()
+                                       while not _it.is_end:
+                                               ve = _it.object
+                                               #print("--------", ve.id.first, ve.id.second)
+                                               self._length = self._length + ve.length_2d
+                                               _it.increment()
+                                               if _it.is_begin:
+                                                       break;
+                                       _it.begin = winner
+                                       _it.current_edge = winner
+                                       _it.orientation = winnerOrientation
+                                       if not _it.is_begin:
+                                               _it.decrement()
+                                               while (not _it.is_end) and (not _it.is_begin):
+                                                       ve = _it.object
+                                                       #print("--------", ve.id.first, ve.id.second)
+                                                       self._length = self._length + ve.length_2d
+                                                       _it.decrement()
+
+                               # let's do the comparison:
+                               # nw let's compute the length of this connex non selected part:
+                               connexl = 0
+                               _cit = pyChainSilhouetteGenericIterator(0,0)
+                               _cit.begin = winner
+                               _cit.current_edge = winner
+                               _cit.orientation = winnerOrientation
+                               _cit.init()
+                               while _cit.is_end == 0 and _cit.object.time_stamp != CF.get_time_stamp():
+                                       ve = _cit.object
+                                       #print("-------- --------", ve.id.first, ve.id.second)
+                                       connexl = connexl + ve.length_2d
+                                       _cit.increment()
+                               if (connexl > self._percent * self._length) or (connexl > self._absLength):
+                                       winner = None
+               return winner
+
+## Chaining iterator that fills small occlusions without caring about the 
+## actual selection
+##     percent
+##             The max length of the occluded part 
+##             expressed in % of the total chain length
+class pyFillQi0AbsoluteAndRelativeChainingIterator(ChainingIterator):
+       def __init__(self, percent, l):
+               ChainingIterator.__init__(self, False, True, None, True)
+               self._length = 0
+               self._absLength = l
+               self._percent = float(percent)
+       def init(self):
+               # each time we're evaluating a chain length 
+               # we try to do it once. Thus we reinit 
+               # the chain length here:
+               self._length = 0
+       def traverse(self, iter):
+               winner = None
+               winnerOrientation = 0
+               print(self.current_edge.id.first, self.current_edge.id.second)
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               if ve.id == mateVE.id:
+                                       winner = ve
+                                       if not it.is_incoming:
+                                               winnerOrientation = 1
+                                       else:
+                                               winnerOrientation = 0
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for nat in natures:
+                               if (self.current_edge.nature & nat) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               ve = it.object
+                                               if (ve.nature & nat) != 0:
+                                                       count = count+1
+                                                       winner = ve
+                                                       if not it.is_incoming:
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               if winner is not None:
+                       # check whether this edge was part of the selection
+                       if winner.qi != 0:
+                               #print("---", winner.id.first, winner.id.second)
+                               # if not, let's check whether it's short enough with
+                               # respect to the chain made without staying in the selection
+                               #------------------------------------------------------------
+                               # Did we compute the prospective chain length already ?
+                               if self._length == 0:
+                                       #if not, let's do it
+                                       _it = pyChainSilhouetteGenericIterator(0,0)
+                                       _it.begin = winner
+                                       _it.current_edge = winner
+                                       _it.orientation = winnerOrientation
+                                       _it.init()
+                                       while not _it.is_end:
+                                               ve = _it.object
+                                               #print("--------", ve.id.first, ve.id.second)
+                                               self._length = self._length + ve.length_2d
+                                               _it.increment()
+                                               if _it.is_begin:
+                                                       break;
+                                       _it.begin = winner
+                                       _it.current_edge = winner
+                                       _it.orientation = winnerOrientation
+                                       if not _it.is_begin:
+                                               _it.decrement()
+                                               while (not _it.is_end) and (not _it.is_begin):
+                                                       ve = _it.object
+                                                       #print("--------", ve.id.first, ve.id.second)
+                                                       self._length = self._length + ve.length_2d
+                                                       _it.decrement()
+
+                               # let's do the comparison:
+                               # nw let's compute the length of this connex non selected part:
+                               connexl = 0
+                               _cit = pyChainSilhouetteGenericIterator(0,0)
+                               _cit.begin = winner
+                               _cit.current_edge = winner
+                               _cit.orientation = winnerOrientation
+                               _cit.init()
+                               while not _cit.is_end and _cit.object.qi != 0:
+                                       ve = _cit.object
+                                       #print("-------- --------", ve.id.first, ve.id.second)
+                                       connexl = connexl + ve.length_2d
+                                       _cit.increment()
+                               if (connexl > self._percent * self._length) or (connexl > self._absLength):
+                                       winner = None
+               return winner
+
+
+## the natural chaining iterator
+## It follows the edges of same nature on the same
+## objects with  preseance on silhouettes, then borders, 
+## then suggestive contours, then everything else. It doesn't chain the same ViewEdge twice
+## You can specify whether to stay in the selection or not.
+class pyNoIdChainSilhouetteIterator(ChainingIterator):
+       def __init__(self, stayInSelection=True):
+               ChainingIterator.__init__(self, stayInSelection, True, None, True)
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.next_vertex
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.get_mate(self.current_edge)
+                       while not it.is_end:
+                               ve = it.object
+                               feB = self.current_edge.last_fedge
+                               feA = ve.first_fedge
+                               vB = feB.second_svertex
+                               vA = feA.first_svertex
+                               if vA.id.first == vB.id.first:
+                                       winner = ve
+                                       break
+                               feA = self.current_edge.first_fedge
+                               feB = ve.last_fedge
+                               vB = feB.second_svertex
+                               vA = feA.first_svertex
+                               if vA.id.first == vB.id.first:
+                                       winner = ve
+                                       break
+                               feA = self.current_edge.last_fedge
+                               feB = ve.last_fedge
+                               vB = feB.second_svertex
+                               vA = feA.second_svertex
+                               if vA.id.first == vB.id.first:
+                                       winner = ve
+                                       break
+                               feA = self.current_edge.first_fedge
+                               feB = ve.first_fedge
+                               vB = feB.first_svertex
+                               vA = feA.first_svertex
+                               if vA.id.first == vB.id.first:
+                                       winner = ve
+                                       break
+                               it.increment()
+               else:
+                       ## case of NonTVertex
+                       natures = [Nature.SILHOUETTE,Nature.BORDER,Nature.CREASE,Nature.SUGGESTIVE_CONTOUR,Nature.VALLEY,Nature.RIDGE]
+                       for i in range(len(natures)):
+                               currentNature = self.current_edge.nature
+                               if (natures[i] & currentNature) != 0:
+                                       count=0
+                                       while not it.is_end:
+                                               visitNext = 0
+                                               oNature = it.object.nature
+                                               if (oNature & natures[i]) != 0:
+                                                       if natures[i] != oNature:
+                                                               for j in range(i):
+                                                                       if (natures[j] & oNature) != 0:
+                                                                               visitNext = 1
+                                                                               break
+                                                               if visitNext != 0:
+                                                                       break    
+                                                       count = count+1
+                                                       winner = it.object
+                                               it.increment()
+                                       if count != 1:
+                                               winner = None
+                                       break
+               return winner
+
diff --git a/release/scripts/freestyle/style_modules/Functions0D.py b/release/scripts/freestyle/style_modules/Functions0D.py
new file mode 100644 (file)
index 0000000..7e5581a
--- /dev/null
@@ -0,0 +1,100 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+from Freestyle import Curvature2DAngleF0D, CurvePoint, ReadCompleteViewMapPixelF0D, \
+    ReadSteerableViewMapPixelF0D, UnaryFunction0DDouble, UnaryFunction0DMaterial, \
+    UnaryFunction0DVec2f
+from Freestyle import ContextFunctions as CF
+
+import math
+import mathutils
+
+class CurveMaterialF0D(UnaryFunction0DMaterial):
+       # A replacement of the built-in MaterialF0D for stroke creation.
+       # MaterialF0D does not work with Curves and Strokes.
+       def __call__(self, inter):
+               cp = inter.object
+               assert(isinstance(cp, CurvePoint))
+               fe = cp.first_svertex.get_fedge(cp.second_svertex)
+               assert(fe is not None)
+               return fe.material if fe.is_smooth else fe.material_left
+
+class pyInverseCurvature2DAngleF0D(UnaryFunction0DDouble):
+       def __call__(self, inter):
+               func = Curvature2DAngleF0D()
+               c = func(inter)
+               return (3.1415 - c)
+
+class pyCurvilinearLengthF0D(UnaryFunction0DDouble):
+       def __call__(self, inter):
+               cp = inter.object               
+               assert(isinstance(cp, CurvePoint))
+               return cp.t2d
+
+## estimate anisotropy of density
+class pyDensityAnisotropyF0D(UnaryFunction0DDouble):
+       def __init__(self,level):
+               UnaryFunction0DDouble.__init__(self)
+               self.IsoDensity = ReadCompleteViewMapPixelF0D(level)
+               self.d0Density = ReadSteerableViewMapPixelF0D(0, level)
+               self.d1Density = ReadSteerableViewMapPixelF0D(1, level)
+               self.d2Density = ReadSteerableViewMapPixelF0D(2, level)
+               self.d3Density = ReadSteerableViewMapPixelF0D(3, level)
+       def __call__(self, inter):
+               c_iso = self.IsoDensity(inter) 
+               c_0 = self.d0Density(inter) 
+               c_1 = self.d1Density(inter) 
+               c_2 = self.d2Density(inter) 
+               c_3 = self.d3Density(inter) 
+               cMax = max(max(c_0,c_1), max(c_2,c_3))
+               cMin = min(min(c_0,c_1), min(c_2,c_3))
+               if c_iso == 0:
+                       v = 0
+               else:
+                       v = (cMax-cMin)/c_iso
+               return v
+
+## Returns the gradient vector for a pixel 
+##     l
+##       the level at which one wants to compute the gradient
+class pyViewMapGradientVectorF0D(UnaryFunction0DVec2f):
+       def __init__(self, l):
+               UnaryFunction0DVec2f.__init__(self)
+               self._l = l
+               self._step = math.pow(2,self._l)
+       def __call__(self, iter):
+               p = iter.object.point_2d
+               gx = CF.read_complete_view_map_pixel(self._l, int(p.x+self._step), int(p.y)) - \
+                   CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
+               gy = CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y+self._step)) - \
+                   CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
+               return mathutils.Vector([gx, gy])
+
+class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
+       def __init__(self, l):
+               UnaryFunction0DDouble.__init__(self)
+               self._l = l
+               self._step = math.pow(2,self._l)
+       def __call__(self, iter):
+               p = iter.object.point_2d
+               gx = CF.read_complete_view_map_pixel(self._l, int(p.x+self._step), int(p.y)) - \
+                   CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
+               gy = CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y+self._step)) - \
+                   CF.read_complete_view_map_pixel(self._l, int(p.x), int(p.y))
+               grad = mathutils.Vector([gx, gy])
+               return grad.length
diff --git a/release/scripts/freestyle/style_modules/Functions1D.py b/release/scripts/freestyle/style_modules/Functions1D.py
new file mode 100644 (file)
index 0000000..4280c9b
--- /dev/null
@@ -0,0 +1,53 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+from Freestyle import GetProjectedZF1D, IntegrationType, UnaryFunction1DDouble, integrate
+from Functions0D import pyDensityAnisotropyF0D, pyViewMapGradientNormF0D
+import string 
+
+class pyGetInverseProjectedZF1D(UnaryFunction1DDouble):
+       def __call__(self, inter):
+               func = GetProjectedZF1D()
+               z = func(inter)
+               return (1.0 - z)
+
+class pyGetSquareInverseProjectedZF1D(UnaryFunction1DDouble):
+       def __call__(self, inter):
+               func = GetProjectedZF1D()
+               z = func(inter)
+               return (1.0 - z*z)
+
+class pyDensityAnisotropyF1D(UnaryFunction1DDouble):
+       def __init__(self,level,  integrationType=IntegrationType.MEAN, sampling=2.0):
+               UnaryFunction1DDouble.__init__(self, integrationType)
+               self._func = pyDensityAnisotropyF0D(level)
+               self._integration = integrationType
+               self._sampling = sampling
+       def __call__(self, inter):
+               v = integrate(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
+               return v
+
+class pyViewMapGradientNormF1D(UnaryFunction1DDouble):
+       def __init__(self,l, integrationType, sampling=2.0):
+               UnaryFunction1DDouble.__init__(self, integrationType)
+               self._func = pyViewMapGradientNormF0D(l)
+               self._integration = integrationType
+               self._sampling = sampling
+       def __call__(self, inter):
+               v = integrate(self._func, inter.pointsBegin(self._sampling), inter.pointsEnd(self._sampling), self._integration)
+               return v
diff --git a/release/scripts/freestyle/style_modules/PredicatesB1D.py b/release/scripts/freestyle/style_modules/PredicatesB1D.py
new file mode 100644 (file)
index 0000000..d38003c
--- /dev/null
@@ -0,0 +1,68 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+from Freestyle import BinaryPredicate1D, GetZF1D, IntegrationType, Nature, SameShapeIdBP1D, ZDiscontinuityF1D
+from Functions1D import pyViewMapGradientNormF1D
+
+import random
+
+class pyZBP1D(BinaryPredicate1D):
+       def __call__(self, i1, i2):
+               func = GetZF1D()
+               return (func(i1) > func(i2))
+
+class pyZDiscontinuityBP1D(BinaryPredicate1D):
+       def __init__(self, iType = IntegrationType.MEAN):
+               BinaryPredicate1D.__init__(self)
+               self._GetZDiscontinuity = ZDiscontinuityF1D(iType)
+       def __call__(self, i1, i2):
+               return (self._GetZDiscontinuity(i1) > self._GetZDiscontinuity(i2))
+
+class pyLengthBP1D(BinaryPredicate1D):
+       def __call__(self, i1, i2):
+               return (i1.length_2d > i2.length_2d)
+
+class pySilhouetteFirstBP1D(BinaryPredicate1D):
+       def __call__(self, inter1, inter2):
+               bpred = SameShapeIdBP1D()
+               if (bpred(inter1, inter2) != 1):
+                       return 0
+               if (inter1.nature & Nature.SILHOUETTE):
+                       return (inter2.nature & Nature.SILHOUETTE) != 0
+               return (inter1.nature == inter2.nature)
+
+class pyNatureBP1D(BinaryPredicate1D):
+       def __call__(self, inter1, inter2):
+               return (inter1.nature & inter2.nature)
+
+class pyViewMapGradientNormBP1D(BinaryPredicate1D):
+       def __init__(self,l, sampling=2.0):
+               BinaryPredicate1D.__init__(self)
+               self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
+       def __call__(self, i1,i2):
+               print("compare gradient")
+               return (self._GetGradient(i1) > self._GetGradient(i2))
+
+class pyShuffleBP1D(BinaryPredicate1D):
+       def __init__(self):
+               BinaryPredicate1D.__init__(self)
+               random.seed(1)
+       def __call__(self, inter1, inter2):
+               r1 = random.uniform(0,1)
+               r2 = random.uniform(0,1)
+               return (r1<r2)
diff --git a/release/scripts/freestyle/style_modules/PredicatesU0D.py b/release/scripts/freestyle/style_modules/PredicatesU0D.py
new file mode 100644 (file)
index 0000000..fd13e41
--- /dev/null
@@ -0,0 +1,91 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+from Freestyle import Curvature2DAngleF0D, Nature, QuantitativeInvisibilityF0D, UnaryPredicate0D
+from Functions0D import pyCurvilinearLengthF0D
+
+class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):
+       def __init__(self,a):
+               UnaryPredicate0D.__init__(self)
+               self._a = a
+       def __call__(self, inter):
+               func = Curvature2DAngleF0D()
+               a = func(inter)
+               return (a > self._a)
+
+class pyUEqualsUP0D(UnaryPredicate0D):
+       def __init__(self,u, w):
+               UnaryPredicate0D.__init__(self)
+               self._u = u
+               self._w = w
+       def __call__(self, inter):
+               func = pyCurvilinearLengthF0D()
+               u = func(inter)
+               return (u > (self._u-self._w)) and (u < (self._u+self._w))
+
+class pyVertexNatureUP0D(UnaryPredicate0D):
+       def __init__(self,nature):
+               UnaryPredicate0D.__init__(self)
+               self._nature = nature
+       def __call__(self, inter):
+               v = inter.object
+               return (v.nature & self._nature) != 0
+
+## check whether an Interface0DIterator
+## is a TVertex and is the one that is 
+## hidden (inferred from the context)
+class pyBackTVertexUP0D(UnaryPredicate0D):
+       def __init__(self):
+               UnaryPredicate0D.__init__(self)
+               self._getQI = QuantitativeInvisibilityF0D()
+       def __call__(self, iter):
+               if (iter.object.nature & Nature.T_VERTEX) == 0:
+                       return 0
+               if iter.is_end:
+                       return 0
+               if self._getQI(iter) != 0:
+                       return 1
+               return 0
+
+class pyParameterUP0DGoodOne(UnaryPredicate0D):
+       def __init__(self,pmin,pmax):
+               UnaryPredicate0D.__init__(self)
+               self._m = pmin
+               self._M = pmax
+               #self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
+       def __call__(self, inter):
+               #s = self.getCurvilinearAbscissa(inter)
+               u = inter.u
+               #print(u)
+               return ((u>=self._m) and (u<=self._M))
+
+class pyParameterUP0D(UnaryPredicate0D):
+       def __init__(self,pmin,pmax):
+               UnaryPredicate0D.__init__(self)
+               self._m = pmin
+               self._M = pmax
+               #self.getCurvilinearAbscissa = GetCurvilinearAbscissaF0D()
+       def __call__(self, inter):
+               func = Curvature2DAngleF0D()
+               c = func(inter)
+               b1 = (c>0.1)
+               #s = self.getCurvilinearAbscissa(inter)
+               u = inter.u
+               #print(u)
+               b = ((u>=self._m) and (u<=self._M))
+               return b and b1
diff --git a/release/scripts/freestyle/style_modules/PredicatesU1D.py b/release/scripts/freestyle/style_modules/PredicatesU1D.py
new file mode 100644 (file)
index 0000000..735c8ff
--- /dev/null
@@ -0,0 +1,338 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+from Freestyle import Curvature2DAngleF0D, CurveNatureF1D, DensityF1D, GetCompleteViewMapDensityF1D, \
+    GetDirectionalViewMapDensityF1D, GetOccludersF1D, GetProjectedZF1D, GetShapeF1D, GetSteerableViewMapDensityF1D, \
+    IntegrationType, ShapeUP1D, TVertex, UnaryPredicate1D
+from Functions1D import pyDensityAnisotropyF1D, pyViewMapGradientNormF1D
+
+count = 0
+class pyNFirstUP1D(UnaryPredicate1D):
+       def __init__(self, n):
+               UnaryPredicate1D.__init__(self)
+               self.__n = n
+       def __call__(self, inter):
+               global count
+               count = count + 1
+               if count <= self.__n:
+                       return 1
+               return 0
+
+class pyHigherLengthUP1D(UnaryPredicate1D):
+       def __init__(self,l):
+               UnaryPredicate1D.__init__(self)
+               self._l = l
+       def __call__(self, inter):
+               return (inter.length_2d > self._l)
+
+class pyNatureUP1D(UnaryPredicate1D):
+       def __init__(self,nature):
+               UnaryPredicate1D.__init__(self)
+               self._nature = nature
+               self._getNature = CurveNatureF1D()
+       def __call__(self, inter):
+               if(self._getNature(inter) & self._nature):
+                       return 1
+               return 0
+
+class pyHigherNumberOfTurnsUP1D(UnaryPredicate1D):
+       def __init__(self,n,a):
+               UnaryPredicate1D.__init__(self)
+               self._n = n
+               self._a = a
+       def __call__(self, inter):
+               count = 0
+               func = Curvature2DAngleF0D()
+               it = inter.vertices_begin()
+               while not it.is_end:
+                       if func(it) > self._a:
+                               count = count+1
+                       if count > self._n:
+                               return 1
+                       it.increment()
+               return 0
+
+class pyDensityUP1D(UnaryPredicate1D):
+       def __init__(self,wsize,threshold, integration = IntegrationType.MEAN, sampling=2.0):
+               UnaryPredicate1D.__init__(self)
+               self._wsize = wsize
+               self._threshold = threshold
+               self._integration = integration
+               self._func = DensityF1D(self._wsize, self._integration, sampling)
+       def __call__(self, inter):
+               if self._func(inter) < self._threshold:
+                       return 1
+               return 0
+
+class pyLowSteerableViewMapDensityUP1D(UnaryPredicate1D):
+       def __init__(self,threshold, level,integration = IntegrationType.MEAN):
+               UnaryPredicate1D.__init__(self)
+               self._threshold = threshold
+               self._level = level
+               self._integration = integration
+       def __call__(self, inter):
+               func = GetSteerableViewMapDensityF1D(self._level, self._integration)
+               v = func(inter)
+               print(v)
+               if v < self._threshold:
+                       return 1
+               return 0
+
+class pyLowDirectionalViewMapDensityUP1D(UnaryPredicate1D):
+       def __init__(self,threshold, orientation, level,integration = IntegrationType.MEAN):
+               UnaryPredicate1D.__init__(self)
+               self._threshold = threshold
+               self._orientation = orientation
+               self._level = level
+               self._integration = integration
+       def __call__(self, inter):
+               func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration)
+               v = func(inter)
+               #print(v)
+               if v < self._threshold:
+                       return 1
+               return 0
+
+class pyHighSteerableViewMapDensityUP1D(UnaryPredicate1D):
+       def __init__(self,threshold, level,integration = IntegrationType.MEAN):
+               UnaryPredicate1D.__init__(self)
+               self._threshold = threshold
+               self._level = level
+               self._integration = integration
+               self._func = GetSteerableViewMapDensityF1D(self._level, self._integration)      
+       def __call__(self, inter):
+               v = self._func(inter)
+               if v > self._threshold:
+                       return 1
+               return 0
+
+class pyHighDirectionalViewMapDensityUP1D(UnaryPredicate1D):
+       def __init__(self,threshold, orientation, level,integration = IntegrationType.MEAN, sampling=2.0):
+               UnaryPredicate1D.__init__(self)
+               self._threshold = threshold
+               self._orientation = orientation
+               self._level = level
+               self._integration = integration
+               self._sampling = sampling               
+       def __call__(self, inter):
+               func = GetDirectionalViewMapDensityF1D(self._orientation, self._level, self._integration, self._sampling)
+               v = func(inter)
+               if v > self._threshold:
+                       return 1
+               return 0
+
+class pyHighViewMapDensityUP1D(UnaryPredicate1D):
+       def __init__(self,threshold, level,integration = IntegrationType.MEAN, sampling=2.0):
+               UnaryPredicate1D.__init__(self)
+               self._threshold = threshold
+               self._level = level
+               self._integration = integration
+               self._sampling = sampling
+               self._func = GetCompleteViewMapDensityF1D(self._level, self._integration, self._sampling) # 2.0 is the smpling
+       def __call__(self, inter):
+               #print("toto")
+               #print(func.name)
+               #print(inter.name)
+               v= self._func(inter)
+               if v > self._threshold:
+                       return 1
+               return 0
+
+class pyDensityFunctorUP1D(UnaryPredicate1D):
+       def __init__(self,wsize,threshold, functor, funcmin=0.0, funcmax=1.0, integration = IntegrationType.MEAN):
+               UnaryPredicate1D.__init__(self)
+               self._wsize = wsize
+               self._threshold = float(threshold)
+               self._functor = functor
+               self._funcmin = float(funcmin)
+               self._funcmax = float(funcmax)
+               self._integration = integration
+       def __call__(self, inter):
+               func = DensityF1D(self._wsize, self._integration)
+               res = self._functor(inter)
+               k = (res-self._funcmin)/(self._funcmax-self._funcmin)
+               if func(inter) < self._threshold*k:
+                       return 1
+               return 0
+
+class pyZSmallerUP1D(UnaryPredicate1D):
+       def __init__(self,z, integration=IntegrationType.MEAN):
+               UnaryPredicate1D.__init__(self)
+               self._z = z
+               self._integration = integration
+       def __call__(self, inter):
+               func = GetProjectedZF1D(self._integration)
+               if func(inter) < self._z:
+                       return 1
+               return 0
+
+class pyIsOccludedByUP1D(UnaryPredicate1D):
+       def __init__(self,id):
+               UnaryPredicate1D.__init__(self)
+               self._id = id
+       def __call__(self, inter):
+               func = GetShapeF1D()
+               shapes = func(inter)
+               for s in shapes:
+                       if(s.id == self._id):
+                               return 0
+               it = inter.vertices_begin()
+               itlast = inter.vertices_end()
+               itlast.decrement()
+               v =  it.object
+               vlast = itlast.object
+               tvertex = v.viewvertex
+               if type(tvertex) is TVertex:
+                       print("TVertex: [ ", tvertex.id.first, ",",  tvertex.id.second," ]")
+                       eit = tvertex.edges_begin()
+                       while not eit.is_end:
+                               ve, incoming = eit.object
+                               if ve.id == self._id:
+                                       return 1
+                               print("-------", ve.id.first, "-", ve.id.second)
+                               eit.increment()
+               tvertex = vlast.viewvertex
+               if type(tvertex) is TVertex:
+                       print("TVertex: [ ", tvertex.id.first, ",",  tvertex.id.second," ]")
+                       eit = tvertex.edges_begin()
+                       while not eit.is_end:
+                               ve, incoming = eit.object
+                               if ve.id == self._id:
+                                       return 1
+                               print("-------", ve.id.first, "-", ve.id.second)
+                               eit.increment()
+               return 0
+
+class pyIsInOccludersListUP1D(UnaryPredicate1D):
+       def __init__(self,id):
+               UnaryPredicate1D.__init__(self)
+               self._id = id
+       def __call__(self, inter):
+               func = GetOccludersF1D()
+               occluders = func(inter)
+               for a in occluders:
+                       if a.id == self._id:
+                               return 1
+               return 0
+
+class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
+       def __init__(self):
+               UnaryPredicate1D.__init__(self)
+               self.__func1 = GetOccludersF1D()
+               self.__func2 = GetShapeF1D()
+       def __call__(self, inter):
+               lst1 = self.__func1(inter)
+               lst2 = self.__func2(inter)
+               for vs1 in lst1:
+                       for vs2 in lst2:
+                               if vs1.id == vs2.id:
+                                       return 1
+               return 0
+
+class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
+       def __init__(self, idlist):
+               UnaryPredicate1D.__init__(self)
+               self._idlist = idlist
+               self.__func1 = GetOccludersF1D()
+       def __call__(self, inter):
+               lst1 = self.__func1(inter)
+               for vs1 in lst1:
+                       for _id in self._idlist:
+                               if vs1.id == _id:
+                                       return 1
+               return 0
+
+class pyShapeIdListUP1D(UnaryPredicate1D):
+       def __init__(self,idlist):
+               UnaryPredicate1D.__init__(self)
+               self._idlist = idlist
+               self._funcs = []
+               for _id in idlist :
+                       self._funcs.append(ShapeUP1D(_id.first, _id.second))
+       def __call__(self, inter):
+               for func in self._funcs :
+                       if func(inter) == 1:
+                               return 1
+               return 0
+
+## deprecated
+class pyShapeIdUP1D(UnaryPredicate1D):
+       def __init__(self, _id):
+               UnaryPredicate1D.__init__(self)
+               self._id = _id
+       def __call__(self, inter):
+               func = GetShapeF1D()
+               shapes = func(inter)
+               for a in shapes:
+                       if a.id == self._id:
+                               return 1
+               return 0
+
+class pyHighDensityAnisotropyUP1D(UnaryPredicate1D):
+       def __init__(self,threshold, level, sampling=2.0):
+               UnaryPredicate1D.__init__(self)
+               self._l = threshold
+               self.func = pyDensityAnisotropyF1D(level, IntegrationType.MEAN, sampling)
+       def __call__(self, inter):
+               return (self.func(inter) > self._l)
+
+class pyHighViewMapGradientNormUP1D(UnaryPredicate1D):
+       def __init__(self,threshold, l, sampling=2.0):
+               UnaryPredicate1D.__init__(self)
+               self._threshold = threshold
+               self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
+       def __call__(self, inter):
+               gn = self._GetGradient(inter)
+               #print(gn)
+               return (gn > self._threshold)
+
+class pyDensityVariableSigmaUP1D(UnaryPredicate1D):
+       def __init__(self,functor, sigmaMin,sigmaMax, lmin, lmax, tmin, tmax, integration = IntegrationType.MEAN, sampling=2.0):
+               UnaryPredicate1D.__init__(self)
+               self._functor = functor
+               self._sigmaMin = float(sigmaMin)
+               self._sigmaMax = float(sigmaMax)
+               self._lmin = float(lmin)
+               self._lmax = float(lmax)
+               self._tmin = tmin
+               self._tmax = tmax
+               self._integration = integration
+               self._sampling = sampling
+       def __call__(self, inter):
+               sigma = (self._sigmaMax-self._sigmaMin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._sigmaMin
+               t = (self._tmax-self._tmin)/(self._lmax-self._lmin)*(self._functor(inter)-self._lmin) + self._tmin
+               if sigma < self._sigmaMin:
+                       sigma = self._sigmaMin
+               self._func = DensityF1D(sigma, self._integration, self._sampling)
+               d = self._func(inter)
+               if d < t:
+                       return 1
+               return 0
+
+class pyClosedCurveUP1D(UnaryPredicate1D):
+       def __call__(self, inter):
+               it = inter.vertices_begin()
+               itlast = inter.vertices_end()
+               itlast.decrement()      
+               vlast = itlast.object
+               v = it.object
+               print(v.id.first, v.id.second)
+               print(vlast.id.first, vlast.id.second)
+               if v.id == vlast.id:
+                       return 1
+               return 0
diff --git a/release/scripts/freestyle/style_modules/anisotropic_diffusion.py b/release/scripts/freestyle/style_modules/anisotropic_diffusion.py
new file mode 100644 (file)
index 0000000..bc16544
--- /dev/null
@@ -0,0 +1,44 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : anisotropic_diffusion.py
+#  Author   : Fredo Durand
+#  Date     : 12/08/2004
+#  Purpose  : Smoothes lines using an anisotropic diffusion scheme
+
+from Freestyle import ChainPredicateIterator, ConstantThicknessShader, ExternalContourUP1D, IncreasingColorShader, \
+    Operators, QuantitativeInvisibilityUP1D, SamplingShader, Stroke, StrokeTextureShader, TrueBP1D, TrueUP1D
+from logical_operators import AndUP1D, NotUP1D
+from shaders import pyDiffusion2Shader
+
+# pyDiffusion2Shader parameters
+offset = 0.25
+nbIter = 30
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = [
+    ConstantThicknessShader(4),
+    StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, False),
+    SamplingShader(2),
+    pyDiffusion2Shader(offset, nbIter),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/apriori_and_causal_density.py b/release/scripts/freestyle/style_modules/apriori_and_causal_density.py
new file mode 100644 (file)
index 0000000..8284f73
--- /dev/null
@@ -0,0 +1,39 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : apriori_and_causal_density.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Selects the lines with high a priori density and 
+#             subjects them to the causal density so as to avoid 
+#             cluttering
+
+from Freestyle import ChainPredicateIterator, ConstantColorShader, ConstantThicknessShader, IntegrationType, \
+    Operators, QuantitativeInvisibilityUP1D, TrueBP1D
+from PredicatesU1D import pyDensityUP1D, pyHighViewMapDensityUP1D
+from logical_operators import AndUP1D, NotUP1D
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.3, IntegrationType.LAST))
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    ConstantThicknessShader(2),
+    ConstantColorShader(0, 0, 0, 1),
+    ]
+Operators.create(pyDensityUP1D(1, 0.1, IntegrationType.MEAN), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/apriori_density.py b/release/scripts/freestyle/style_modules/apriori_density.py
new file mode 100644 (file)
index 0000000..575f2b9
--- /dev/null
@@ -0,0 +1,37 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : apriori_density.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines having a high a priori density
+
+from Freestyle import ChainPredicateIterator, ConstantColorShader, ConstantThicknessShader, Operators, \
+    QuantitativeInvisibilityUP1D, TrueBP1D, TrueUP1D
+from PredicatesU1D import pyHighViewMapDensityUP1D
+from logical_operators import AndUP1D, NotUP1D
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.1,5)))
+bpred = TrueBP1D()
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.0007,5))
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list =         [
+               ConstantThicknessShader(2), 
+               ConstantColorShader(0.0, 0.0, 0.0,1)
+               ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/backbone_stretcher.py b/release/scripts/freestyle/style_modules/backbone_stretcher.py
new file mode 100644 (file)
index 0000000..1e113be
--- /dev/null
@@ -0,0 +1,35 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : backbone_stretcher.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Stretches the geometry of visible lines
+
+from Freestyle import BackboneStretcherShader, ChainSilhouetteIterator, ConstantColorShader, \
+    Operators, QuantitativeInvisibilityUP1D, TextureAssignerShader, TrueUP1D
+from logical_operators import NotUP1D
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    TextureAssignerShader(4),
+    ConstantColorShader(0.5, 0.5, 0.5),
+    BackboneStretcherShader(20),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/blueprint_circles.py b/release/scripts/freestyle/style_modules/blueprint_circles.py
new file mode 100644 (file)
index 0000000..769615e
--- /dev/null
@@ -0,0 +1,42 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : blueprint_circles.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using circular contour strokes
+
+from Freestyle import ChainPredicateIterator, ConstantThicknessShader, ContourUP1D, IncreasingColorShader, \
+    Operators, QuantitativeInvisibilityUP1D, SameShapeIdBP1D, TextureAssignerShader, TrueUP1D
+from PredicatesU1D import pyHigherLengthUP1D
+from logical_operators import AndUP1D, NotUP1D
+from shaders import pyBluePrintCirclesShader, pyPerlinNoise1DShader
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectional_chain(ChainPredicateIterator(upred,bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+    ConstantThicknessShader(5),
+    pyBluePrintCirclesShader(3),
+    pyPerlinNoise1DShader(0.1, 15, 8),
+    TextureAssignerShader(4),
+    IncreasingColorShader(0.8, 0.8, 0.3, 0.4, 0.3, 0.3, 0.3, 0.1),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/blueprint_ellipses.py b/release/scripts/freestyle/style_modules/blueprint_ellipses.py
new file mode 100644 (file)
index 0000000..70c999f
--- /dev/null
@@ -0,0 +1,42 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : blueprint_ellipses.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using elliptic contour strokes
+
+from Freestyle import ChainPredicateIterator, ConstantThicknessShader, ContourUP1D, IncreasingColorShader, \
+    Operators, QuantitativeInvisibilityUP1D, SameShapeIdBP1D, TextureAssignerShader, TrueUP1D
+from PredicatesU1D import pyHigherLengthUP1D
+from logical_operators import AndUP1D, NotUP1D
+from shaders import pyBluePrintEllipsesShader, pyPerlinNoise1DShader
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+    ConstantThicknessShader(5),
+    pyBluePrintEllipsesShader(3),
+    pyPerlinNoise1DShader(0.1, 10, 8),
+    TextureAssignerShader(4),
+    IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.3, 0.3, 0.3, 0.1),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/blueprint_squares.py b/release/scripts/freestyle/style_modules/blueprint_squares.py
new file mode 100644 (file)
index 0000000..7193beb
--- /dev/null
@@ -0,0 +1,43 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : blueprint_squares.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using square contour strokes
+
+from Freestyle import ChainPredicateIterator, ConstantThicknessShader, ContourUP1D, IncreasingColorShader, \
+    Operators, QuantitativeInvisibilityUP1D, SameShapeIdBP1D, TextureAssignerShader, TrueUP1D
+from PredicatesU1D import pyHigherLengthUP1D
+from logical_operators import AndUP1D, NotUP1D
+from shaders import pyBluePrintSquaresShader, pyPerlinNoise1DShader
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+Operators.select(pyHigherLengthUP1D(200))
+shaders_list = [
+    ConstantThicknessShader(8),
+    pyBluePrintSquaresShader(2, 20),
+    pyPerlinNoise1DShader(0.07, 10, 8),
+    TextureAssignerShader(4),
+    IncreasingColorShader(0.6, 0.3, 0.3, 0.7, 0.6, 0.3, 0.3, 0.3),
+    ConstantThicknessShader(4),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/cartoon.py b/release/scripts/freestyle/style_modules/cartoon.py
new file mode 100644 (file)
index 0000000..61bc115
--- /dev/null
@@ -0,0 +1,38 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : cartoon.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws colored lines. The color is automatically 
+#             infered from each object's material in a cartoon-like
+#             fashion.
+
+from Freestyle import BezierCurveShader, ChainSilhouetteIterator, ConstantThicknessShader, Operators, \
+    QuantitativeInvisibilityUP1D, TrueUP1D
+from logical_operators import NotUP1D
+from shaders import pyMaterialColorShader
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    BezierCurveShader(3),
+    ConstantThicknessShader(4),
+    pyMaterialColorShader(0.8),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/contour.py b/release/scripts/freestyle/style_modules/contour.py
new file mode 100644 (file)
index 0000000..63a4a24
--- /dev/null
@@ -0,0 +1,37 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : contour.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws each object's visible contour
+
+from Freestyle import BezierCurveShader, ChainSilhouetteIterator, ConstantThicknessShader, \
+    Operators, QuantitativeInvisibilityUP1D, TrueUP1D
+from logical_operators import NotUP1D
+from shaders import pyMaterialColorShader
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D()))
+bpred = SameShapeIdBP1D()
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    ConstantThicknessShader(5.0),
+    IncreasingColorShader(0.8,0,0,1,0.1,0,0,1),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/curvature2d.py b/release/scripts/freestyle/style_modules/curvature2d.py
new file mode 100644 (file)
index 0000000..57bc838
--- /dev/null
@@ -0,0 +1,37 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : curvature2d.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The stroke points are colored in gray levels and depending
+#             on the 2d curvature value
+
+from Freestyle import ChainSilhouetteIterator, ConstantThicknessShader, Operators, \
+    QuantitativeInvisibilityUP1D, Stroke, StrokeTextureShader, TrueUP1D
+from logical_operators import NotUP1D
+from shaders import py2DCurvatureColorShader
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, False),
+    ConstantThicknessShader(5),
+    py2DCurvatureColorShader()
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/external_contour.py b/release/scripts/freestyle/style_modules/external_contour.py
new file mode 100644 (file)
index 0000000..28bd28f
--- /dev/null
@@ -0,0 +1,36 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : external_contour.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the external contour of the scene
+
+from Freestyle import ChainPredicateIterator, ConstantColorShader, ConstantThicknessShader, \
+    ExternalContourUP1D, Operators, QuantitativeInvisibilityUP1D, TrueBP1D, TrueUP1D
+from logical_operators import AndUP1D, NotUP1D
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = [
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.0, 0.0, 0.0, 1),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/external_contour_sketchy.py b/release/scripts/freestyle/style_modules/external_contour_sketchy.py
new file mode 100644 (file)
index 0000000..d85e967
--- /dev/null
@@ -0,0 +1,43 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : external_contour_sketchy.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the external contour of the scene using a sketchy 
+#             chaining iterator (in particular each ViewEdge can be drawn 
+#             several times
+
+from ChainingIterators import pySketchyChainingIterator
+from Freestyle import ExternalContourUP1D, IncreasingColorShader, IncreasingThicknessShader, \
+    Operators, QuantitativeInvisibilityUP1D, SamplingShader, SmoothingShader, SpatialNoiseShader, \
+    TextureAssignerShader, TrueUP1D
+from logical_operators import AndUP1D, NotUP1D
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D()) 
+Operators.select(upred)
+Operators.bidirectional_chain(pySketchyChainingIterator(), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(4),
+    SpatialNoiseShader(10, 150, 2, 1, 1),
+    IncreasingThicknessShader(4, 10),
+    SmoothingShader(400, 0.1, 0, 0.2, 0, 0, 0, 1),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+    TextureAssignerShader(4),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/external_contour_smooth.py b/release/scripts/freestyle/style_modules/external_contour_smooth.py
new file mode 100644 (file)
index 0000000..f42f3bf
--- /dev/null
@@ -0,0 +1,39 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : external_contour_smooth.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws a smooth external contour
+
+from Freestyle import ChainPredicateIterator, ExternalContourUP1D, IncreasingColorShader, \
+    IncreasingThicknessShader, Operators, QuantitativeInvisibilityUP1D, SamplingShader, \
+    SmoothingShader, TrueBP1D, TrueUP1D
+from logical_operators import AndUP1D, NotUP1D
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectional_chain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(2),
+    IncreasingThicknessShader(4,20),
+    IncreasingColorShader(1.0, 0.0, 0.5,1, 0.5,1, 0.3, 1),
+    SmoothingShader(100, 0.05, 0, 0.2, 0, 0, 0, 1),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/haloing.py b/release/scripts/freestyle/style_modules/haloing.py
new file mode 100644 (file)
index 0000000..ee907ec
--- /dev/null
@@ -0,0 +1,46 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : haloing.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : This style module selects the lines that 
+#             are connected (in the image) to a specific 
+#             object and trims them in order to produce
+#             a haloing effect around the target shape
+
+from Freestyle import ChainSilhouetteIterator, Id, IncreasingColorShader, IncreasingThicknessShader, \
+    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TipRemoverShader, TrueUP1D
+from PredicatesU1D import pyIsOccludedByUP1D
+from logical_operators import AndUP1D, NotUP1D
+from shaders import pyTVertexRemoverShader
+
+# id corresponds to the id of the target object 
+# (accessed by SHIFT+click)
+id = Id(3,0)
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyIsOccludedByUP1D(id))
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    IncreasingThicknessShader(3, 5), 
+    IncreasingColorShader(1,0,0, 1,0,1,0,1),
+    SamplingShader(1.0),
+    pyTVertexRemoverShader(),
+    TipRemoverShader(3.0),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/ignore_small_occlusions.py b/release/scripts/freestyle/style_modules/ignore_small_occlusions.py
new file mode 100644 (file)
index 0000000..aeab1b2
--- /dev/null
@@ -0,0 +1,36 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : ignore_small_oclusions.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The strokes are drawn through small occlusions
+
+from ChainingIterators import pyFillOcclusionsAbsoluteChainingIterator
+from Freestyle import ConstantColorShader, ConstantThicknessShader, Operators, \
+    QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+#Operators.bidirectional_chain(pyFillOcclusionsChainingIterator(0.1))
+Operators.bidirectional_chain(pyFillOcclusionsAbsoluteChainingIterator(12))
+shaders_list = [
+    SamplingShader(5.0),
+    ConstantThicknessShader(3),
+    ConstantColorShader(0.0, 0.0, 0.0),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/invisible_lines.py b/release/scripts/freestyle/style_modules/invisible_lines.py
new file mode 100644 (file)
index 0000000..6a72534
--- /dev/null
@@ -0,0 +1,37 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : invisible_lines.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws all lines whose Quantitative Invisibility 
+#             is different from 0
+
+from Freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
+    Operators, QuantitativeInvisibilityUP1D, SamplingShader, TrueUP1D
+from logical_operators import NotUP1D
+
+upred = NotUP1D(QuantitativeInvisibilityUP1D(0))
+Operators.select(upred)
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred))
+shaders_list = [
+    SamplingShader(5.0),
+    ConstantThicknessShader(3.0),
+    ConstantColorShader(0.7, 0.7, 0.7),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/japanese_bigbrush.py b/release/scripts/freestyle/style_modules/japanese_bigbrush.py
new file mode 100644 (file)
index 0000000..ca42153
--- /dev/null
@@ -0,0 +1,56 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : japanese_bigbrush.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Simulates a big brush fr oriental painting
+
+from Freestyle import BezierCurveShader, ChainSilhouetteIterator, ConstantColorShader, \
+    ConstantThicknessShader, IntegrationType, Operators, QuantitativeInvisibilityUP1D, \
+    SamplingShader, TextureAssignerShader, TipRemoverShader
+from Functions0D import pyInverseCurvature2DAngleF0D
+from PredicatesB1D import pyLengthBP1D
+from PredicatesU0D import pyParameterUP0D
+from PredicatesU1D import pyDensityUP1D, pyHigherLengthUP1D, pyHigherNumberOfTurnsUP1D
+from logical_operators import NotUP1D
+from shaders import pyNonLinearVaryingThicknessShader, pySamplingShader
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+## Splits strokes at points of highest 2D curavture 
+## when there are too many abrupt turns in it
+func = pyInverseCurvature2DAngleF0D()
+Operators.recursive_split(func, pyParameterUP0D(0.2, 0.8), NotUP1D(pyHigherNumberOfTurnsUP1D(3, 0.5)), 2)
+## Keeps only long enough strokes
+Operators.select(pyHigherLengthUP1D(100))
+## Sorts so as to draw the longest strokes first
+## (this will be done using the causal density)
+Operators.sort(pyLengthBP1D())
+shaders_list = [
+    pySamplingShader(10),
+    BezierCurveShader(30),
+    SamplingShader(50),
+    ConstantThicknessShader(10),
+    pyNonLinearVaryingThicknessShader(4, 25, 0.6),
+    TextureAssignerShader(6),
+    ConstantColorShader(0.2, 0.2, 0.2,1.0),
+    TipRemoverShader(10),
+    ]
+## Use the causal density to avoid cluttering
+Operators.create(pyDensityUP1D(8, 0.4, IntegrationType.MEAN), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/logical_operators.py b/release/scripts/freestyle/style_modules/logical_operators.py
new file mode 100644 (file)
index 0000000..6de9c0f
--- /dev/null
@@ -0,0 +1,42 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+from Freestyle import UnaryPredicate1D
+
+class AndUP1D(UnaryPredicate1D):
+    def __init__(self, pred1, pred2):
+        UnaryPredicate1D.__init__(self)
+        self.__pred1 = pred1
+        self.__pred2 = pred2
+    def __call__(self, inter):
+        return self.__pred1(inter) and self.__pred2(inter)
+    
+class OrUP1D(UnaryPredicate1D):
+    def __init__(self, pred1, pred2):
+        UnaryPredicate1D.__init__(self)
+        self.__pred1 = pred1
+        self.__pred2 = pred2
+    def __call__(self, inter):
+        return self.__pred1(inter) or self.__pred2(inter)
+
+class NotUP1D(UnaryPredicate1D):
+    def __init__(self, pred):
+        UnaryPredicate1D.__init__(self)
+        self.__pred = pred
+    def __call__(self, inter):
+        return not self.__pred(inter)
diff --git a/release/scripts/freestyle/style_modules/long_anisotropically_dense.py b/release/scripts/freestyle/style_modules/long_anisotropically_dense.py
new file mode 100644 (file)
index 0000000..90fc84c
--- /dev/null
@@ -0,0 +1,68 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : long_anisotropically_dense.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Selects the lines that are long and have a high anisotropic 
+#             a priori density and uses causal density 
+#             to draw without cluttering. Ideally, half of the
+#             selected lines are culled using the causal density.
+#
+#             ********************* WARNING *************************************
+#             ******** The Directional a priori density maps must          ****** 
+#             ******** have been computed prior to using this style module ******
+
+from Freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, DensityF1D, \
+    IntegrationType, Operators, QuantitativeInvisibilityUP1D, SamplingShader, UnaryPredicate1D
+from PredicatesB1D import pyLengthBP1D
+from PredicatesU1D import pyHighDensityAnisotropyUP1D, pyHigherLengthUP1D
+from logical_operators import NotUP1D
+
+## custom density predicate
+class pyDensityUP1D(UnaryPredicate1D):
+    def __init__(self, wsize, threshold, integration=IntegrationType.MEAN, sampling=2.0):
+        UnaryPredicate1D.__init__(self)
+        self._wsize = wsize
+        self._threshold = threshold
+        self._integration = integration
+        self._func = DensityF1D(self._wsize, self._integration, sampling)
+        self._func2 = DensityF1D(self._wsize, IntegrationType.MAX, sampling)
+    def __call__(self, inter):
+        c = self._func(inter)
+        m = self._func2(inter)
+        if c < self._threshold:
+            return 1
+        if m > 4*c:
+            if c < 1.5*self._threshold:
+                return 1
+        return 0
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectional_chain(ChainSilhouetteIterator(),NotUP1D(QuantitativeInvisibilityUP1D(0)))
+Operators.select(pyHigherLengthUP1D(40))
+## selects lines having a high anisotropic a priori density
+Operators.select(pyHighDensityAnisotropyUP1D(0.3,4))
+Operators.sort(pyLengthBP1D())
+shaders_list = [
+    SamplingShader(2.0),
+    ConstantThicknessShader(2),
+    ConstantColorShader(0.2,0.2,0.25,1), 
+    ]
+## uniform culling
+Operators.create(pyDensityUP1D(3.0,2.0e-2, IntegrationType.MEAN, 0.1), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/multiple_parameterization.py b/release/scripts/freestyle/style_modules/multiple_parameterization.py
new file mode 100644 (file)
index 0000000..2296a97
--- /dev/null
@@ -0,0 +1,47 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : multiple_parameterization.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The thickness and the color of the strokes vary continuously 
+#             independently from occlusions although only
+#             visible lines are actually drawn. This is equivalent
+#             to assigning the thickness using a parameterization covering
+#             the complete silhouette (visible+invisible) and drawing
+#             the strokes using a second parameterization that only
+#             covers the visible portions.
+
+from Freestyle import ChainSilhouetteIterator, ConstantColorShader, IncreasingColorShader, \
+    IncreasingThicknessShader, Operators, QuantitativeInvisibilityUP1D, SamplingShader, \
+    TextureAssignerShader, TrueUP1D
+from shaders import pyHLRShader
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+## Chain following the same nature, but without the restriction
+## of staying inside the selection (0).
+Operators.bidirectional_chain(ChainSilhouetteIterator(0))
+shaders_list = [
+    SamplingShader(20),
+    IncreasingThicknessShader(1.5, 30),
+    ConstantColorShader(0.0, 0.0, 0.0),
+    IncreasingColorShader(1, 0, 0, 1, 0, 1, 0, 1),
+    TextureAssignerShader(-1),
+    pyHLRShader(), ## this shader draws only visible portions
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/nature.py b/release/scripts/freestyle/style_modules/nature.py
new file mode 100644 (file)
index 0000000..dd520c5
--- /dev/null
@@ -0,0 +1,39 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : nature.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Uses the NatureUP1D predicate to select the lines
+#             of a given type (among Nature.SILHOUETTE, Nature.CREASE, Nature.SUGGESTIVE_CONTOURS,
+#             Nature.BORDERS).
+#             The suggestive contours must have been enabled in the 
+#             options dialog to appear in the View Map.
+
+from Freestyle import ChainSilhouetteIterator, IncreasingColorShader, \
+    IncreasingThicknessShader, Nature, Operators, TrueUP1D
+from PredicatesU1D import pyNatureUP1D
+from logical_operators import NotUP1D
+
+Operators.select(pyNatureUP1D(Nature.SILHOUETTE))
+Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(pyNatureUP1D(Nature.SILHOUETTE)))
+shaders_list = [
+    IncreasingThicknessShader(3, 10),
+    IncreasingColorShader(0.0, 0.0, 0.0, 1, 0.8, 0, 0, 1),
+    ]
+Operators.create(TrueUP1D(), shaders_list)
diff --git a/release/scripts/freestyle/style_modules/near_lines.py b/release/scripts/freestyle/style_modules/near_lines.py
new file mode 100644 (file)
index 0000000..d2dab89
--- /dev/null
@@ -0,0 +1,38 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+#  Filename : near_lines.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the lines that are "closer" than a threshold 
+#             (between 0 and 1)
+
+from Freestyle import ChainSilhouetteIterator, ConstantColorShader, ConstantThicknessShader, \
+    IntegrationType, Operators, QuantitativeInvisibilityUP1D, TextureAssignerShader, TrueUP1D
+from PredicatesU1D import pyZSmallerUP1D
+from logical_operators import AndUP1D, NotUP1D
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), p