Merged changes in the trunk up to revision 54171.
authorTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Tue, 29 Jan 2013 03:42:19 +0000 (03:42 +0000)
committerTamito Kajiyama <rd6t-kjym@asahi-net.or.jp>
Tue, 29 Jan 2013 03:42:19 +0000 (03:42 +0000)
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/extra-lines.sml [new file with mode: 0644]
release/scripts/freestyle/style_modules/freestyle_init.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/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/bmesh_class.h
source/blender/bmesh/intern/bmesh_construct.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_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/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 59dbeaed36b27f4d3d85fdaab6688e7214680fe4..e623cfe290e64b702878f9be8d08be30c43db78a 100644 (file)
@@ -233,6 +233,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 eb22af1455b8d1bf5de778748f5bebffdf565202..70ada74cfa98b15d0ba824f59b60afe8dd8e42e5 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():
@@ -701,6 +702,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 207ddd3579b84aec985628459c4a3d07469c996b..ee1b7bfa38cb66f1177399b465ec071a39853309 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_13', 'sm_20', 'sm_21']
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 #Ray trace optimization
 if MACOSX_ARCHITECTURE == 'x86_64' or MACOSX_ARCHITECTURE == 'i386':
     WITH_BF_RAYOPTIMIZATION = True
index 02c9093567a964c3275dbfd659692a48c3fc2a5e..6c39039c4fb74a3d660602e9975233b3c9690ff1 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 5d3308c50d4c1a399498899115b1b1c13e1f77ad..3318e21bf1db08aea0106ed9ee7f04c607a39c86 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 98c2c8fa50018b4620696404235b10f3c1f66436..b6c5c0d45eb5cad9f62732e0a5f0c6cb68b58286 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 068273e35ef3e633cbde293d64bdd256bd4653ed..22e82662ae782b25b4b48d33185c495321a7d0e0 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 54faf59b2a47092792971ddc169670365b2209a5..925ca5bb8890d34ae92d5b110e53f50d7ecd3c69 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 391421609d2bf64088b562528619fe92bc01e63a..5362e35878ea7da33b48c63f5b47291c4f7d188d 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_13', 'sm_20', 'sm_21', 'sm_30']
 
+#Freestyle
+WITH_BF_FREESTYLE = True
+
 ##
 CC = 'gcc'
 CXX = 'g++'
index 21488e75f7ef1bc8b209f255e48b8f402fda8ef6..cf0afec0ee1129a475468d2ea43a1b2790870a6f 100644 (file)
@@ -195,6 +195,9 @@ BF_CYCLES_CUDA_BINARIES_ARCH = ['sm_13', '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 d00e7a3ffa7043215cda2a604e2193e91ab481ee..5e6e16b1771ab6d192f06c53dcea0fbe6f663286 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 c0ea7972aeb9189679abd18dfafa10f7593a10f9..33f01616579268b77e405a1bf7d3b6c4ce5436eb 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 94a9f1d9c244b3c1005bb43623cdfa8054512dc9..eac26c1a50b335bc4150aa404885ab60b2238282 100644 (file)
@@ -388,6 +388,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 ee6dd20ecc033c4fa6381cf2f34562a73f49c8ab..9a31ba650f5f0e5ab8bd2a9d171a393a3387ee97 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 7457ae02d6c3689c0460868354216d2db33d5d9d..4311ae56f8eef2290fec8f2b1d53dceb62bd0de2 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"
@@ -913,6 +915,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()
@@ -1543,7 +1551,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",
         )
@@ -1691,6 +1699,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 d05ceb5114852ede320ee507959ea8f54f7cc1c4..9d0b6d96f47351c97d14834979bf889046fac526 100644 (file)
@@ -220,10 +220,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
@@ -232,7 +291,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="")
@@ -240,9 +299,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()
@@ -264,6 +338,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()
@@ -300,64 +388,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 599bfb50d6eeca22e442b9ff25d88b0451efd633..dc684178f40e144bb7eab6991b6ccbbd696be52b 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..f2d953d
--- /dev/null
@@ -0,0 +1,731 @@
+#
+#  Filename : ChainingIterators.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Chaining Iterators to be used with chaining operators
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+
+## 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=1):
+               ChainingIterator.__init__(self, stayInSelection, 1,None,1)
+       def getExactTypeName(self):
+               return "pyChainSilhouetteIterator"
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(ve.getId() == mateVE.getId() ):
+                                       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.getCurrentEdge().getNature()
+                               if(natures[i] & currentNature):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               visitNext = 0
+                                               oNature = it.getObject().getNature()
+                                               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.getObject()
+                                               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=1, stayInUnvisited=1):
+               ChainingIterator.__init__(self, stayInSelection, stayInUnvisited,None,1)
+       def getExactTypeName(self):
+               return "pyChainSilhouetteGenericIterator"
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(ve.getId() == mateVE.getId() ):
+                                       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.getCurrentEdge().getNature()
+                               if(natures[i] & currentNature):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               visitNext = 0
+                                               oNature = it.getObject().getNature()
+                                               ve = it.getObject()
+                                               if(ve.getId() == self.getCurrentEdge().getId()):
+                                                       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, 0, 1,None,1)
+               self._isExternalContour = ExternalContourUP1D()
+               
+       def getExactTypeName(self):
+               return "pyExternalContourIterator"
+       
+       def init(self):
+               self._nEdges = 0
+               self._isInSelection = 1
+
+       def checkViewEdge(self, ve, orientation):
+               if(orientation != 0):
+                       vertex = ve.B()
+               else:
+                       vertex = ve.A()
+               it = AdjacencyIterator(vertex,1,1)
+               while(it.isEnd() == 0):
+                       ave = it.getObject()
+                       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(it.isEnd() == 0):
+                       ve = it.getObject()
+                       if(self._isExternalContour(ve)):
+                               if (ve.getTimeStamp() == GetTimeStampCF()):
+                                       winner = ve
+                       it.increment()
+               
+               self._nEdges = self._nEdges+1
+               if(winner == None):
+                       orient = 1
+                       it = AdjacencyIterator(iter)
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(it.isIncoming() != 0):
+                                       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=1):
+               ChainingIterator.__init__(self, stayInSelection, 0,None,1)
+               self._timeStamp = GetTimeStampCF()+nRounds
+               self._nRounds = nRounds
+       def getExactTypeName(self):
+               return "pySketchyChainSilhouetteIterator"
+       def init(self):
+               self._timeStamp = GetTimeStampCF()+self._nRounds
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(ve.getId() == mateVE.getId() ):
+                                       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.getCurrentEdge().getNature()
+                               if(natures[i] & currentNature):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               visitNext = 0
+                                               oNature = it.getObject().getNature()
+                                               ve = it.getObject()
+                                               if(ve.getId() == self.getCurrentEdge().getId()):
+                                                       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
+               if(winner == None):
+                       winner = self.getCurrentEdge()
+               if(winner.getChainingTimeStamp() == 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=1):
+               ChainingIterator.__init__(self, stayInSelection, 0,None,1)
+               self._timeStamp = GetTimeStampCF()+nRounds
+               self._nRounds = nRounds
+       def getExactTypeName(self):
+               return "pySketchyChainingIterator"
+
+       def init(self):
+               self._timeStamp = GetTimeStampCF()+self._nRounds
+
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               while(it.isEnd() == 0):
+                       ve = it.getObject()
+                       if(ve.getId() == self.getCurrentEdge().getId()):
+                               it.increment()
+                               continue
+                       winner = ve
+                       it.increment()
+               if(winner == None):
+                       winner = self.getCurrentEdge()
+               if(winner.getChainingTimeStamp() == 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, 0, 1,None,1)
+               self._length = 0
+               self._percent = float(percent)
+       def getExactTypeName(self):
+               return "pyFillOcclusionsChainingIterator"
+       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.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond())
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(ve.getId() == mateVE.getId() ):
+                                       winner = ve
+                                       if(it.isIncoming() == 0):
+                                               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.getCurrentEdge().getNature() & nat != 0):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               ve = it.getObject()
+                                               if(ve.getNature() & nat != 0):
+                                                       count = count+1
+                                                       winner = ve
+                                                       if(it.isIncoming() == 0):
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if(count != 1):
+                                               winner = None
+                                       break
+               if(winner != None):
+                       # check whether this edge was part of the selection
+                       if(winner.getTimeStamp() != GetTimeStampCF()):
+                               #print("---", winner.getId().getFirst(), winner.getId().getSecond())
+                               # 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.setBegin(winner)
+                                       _it.setCurrentEdge(winner)
+                                       _it.setOrientation(winnerOrientation)
+                                       _it.init()
+                                       while(_it.isEnd() == 0):
+                                               ve = _it.getObject()
+                                               #print("--------", ve.getId().getFirst(), ve.getId().getSecond())
+                                               self._length = self._length + ve.getLength2D()
+                                               _it.increment()
+                                               if(_it.isBegin() != 0):
+                                                       break;
+                                       _it.setBegin(winner)
+                                       _it.setCurrentEdge(winner)
+                                       _it.setOrientation(winnerOrientation)
+                                       if(_it.isBegin() == 0):
+                                               _it.decrement()
+                                               while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
+                                                       ve = _it.getObject()
+                                                       #print("--------", ve.getId().getFirst(), ve.getId().getSecond())
+                                                       self._length = self._length + ve.getLength2D()
+                                                       _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.setBegin(winner)
+                               _cit.setCurrentEdge(winner)
+                               _cit.setOrientation(winnerOrientation)
+                               _cit.init()
+                               while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
+                                       ve = _cit.getObject()
+                                       #print("-------- --------", ve.getId().getFirst(), ve.getId().getSecond())
+                                       connexl = connexl + ve.getLength2D()
+                                       _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, 0, 1,None,1)
+               self._length = float(length)
+       def getExactTypeName(self):
+               return "pySmallFillOcclusionsChainingIterator"
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               winnerOrientation = 0
+               #print(self.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond())
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(ve.getId() == mateVE.getId() ):
+                                       winner = ve
+                                       if(it.isIncoming() == 0):
+                                               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.getCurrentEdge().getNature() & nat != 0):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               ve = it.getObject()
+                                               if(ve.getNature() & nat != 0):
+                                                       count = count+1
+                                                       winner = ve
+                                                       if(it.isIncoming() == 0):
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if(count != 1):
+                                               winner = None
+                                       break
+               if(winner != None):
+                       # check whether this edge was part of the selection
+                       if(winner.getTimeStamp() != GetTimeStampCF()):
+                               #print("---", winner.getId().getFirst(), winner.getId().getSecond())
+                               # nw let's compute the length of this connex non selected part:
+                               connexl = 0
+                               _cit = pyChainSilhouetteGenericIterator(0,0)
+                               _cit.setBegin(winner)
+                               _cit.setCurrentEdge(winner)
+                               _cit.setOrientation(winnerOrientation)
+                               _cit.init()
+                               while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
+                                       ve = _cit.getObject()
+                                       #print("-------- --------", ve.getId().getFirst(), ve.getId().getSecond())
+                                       connexl = connexl + ve.getLength2D()
+                                       _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, 0, 1,None,1)
+               self._length = 0
+               self._absLength = l
+               self._percent = float(percent)
+       def getExactTypeName(self):
+               return "pyFillOcclusionsChainingIterator"
+       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.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond())
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(ve.getId() == mateVE.getId() ):
+                                       winner = ve
+                                       if(it.isIncoming() == 0):
+                                               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.getCurrentEdge().getNature() & nat != 0):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               ve = it.getObject()
+                                               if(ve.getNature() & nat != 0):
+                                                       count = count+1
+                                                       winner = ve
+                                                       if(it.isIncoming() == 0):
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if(count != 1):
+                                               winner = None
+                                       break
+               if(winner != None):
+                       # check whether this edge was part of the selection
+                       if(winner.getTimeStamp() != GetTimeStampCF()):
+                               #print("---", winner.getId().getFirst(), winner.getId().getSecond())
+                               # 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.setBegin(winner)
+                                       _it.setCurrentEdge(winner)
+                                       _it.setOrientation(winnerOrientation)
+                                       _it.init()
+                                       while(_it.isEnd() == 0):
+                                               ve = _it.getObject()
+                                               #print("--------", ve.getId().getFirst(), ve.getId().getSecond())
+                                               self._length = self._length + ve.getLength2D()
+                                               _it.increment()
+                                               if(_it.isBegin() != 0):
+                                                       break;
+                                       _it.setBegin(winner)
+                                       _it.setCurrentEdge(winner)
+                                       _it.setOrientation(winnerOrientation)
+                                       if(_it.isBegin() == 0):
+                                               _it.decrement()
+                                               while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
+                                                       ve = _it.getObject()
+                                                       #print("--------", ve.getId().getFirst(), ve.getId().getSecond())
+                                                       self._length = self._length + ve.getLength2D()
+                                                       _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.setBegin(winner)
+                               _cit.setCurrentEdge(winner)
+                               _cit.setOrientation(winnerOrientation)
+                               _cit.init()
+                               while((_cit.isEnd() == 0) and (_cit.getObject().getTimeStamp() != GetTimeStampCF())):
+                                       ve = _cit.getObject()
+                                       #print("-------- --------", ve.getId().getFirst(), ve.getId().getSecond())
+                                       connexl = connexl + ve.getLength2D()
+                                       _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, 0, 1,None,1)
+               self._length = 0
+               self._absLength = l
+               self._percent = float(percent)
+       def getExactTypeName(self):
+               return "pyFillOcclusionsChainingIterator"
+       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.getCurrentEdge().getId().getFirst(), self.getCurrentEdge().getId().getSecond())
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               if(ve.getId() == mateVE.getId() ):
+                                       winner = ve
+                                       if(it.isIncoming() == 0):
+                                               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.getCurrentEdge().getNature() & nat != 0):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               ve = it.getObject()
+                                               if(ve.getNature() & nat != 0):
+                                                       count = count+1
+                                                       winner = ve
+                                                       if(it.isIncoming() == 0):
+                                                               winnerOrientation = 1
+                                                       else:
+                                                               winnerOrientation = 0
+                                               it.increment()
+                                       if(count != 1):
+                                               winner = None
+                                       break
+               if(winner != None):
+                       # check whether this edge was part of the selection
+                       if(winner.qi() != 0):
+                               #print("---", winner.getId().getFirst(), winner.getId().getSecond())
+                               # 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.setBegin(winner)
+                                       _it.setCurrentEdge(winner)
+                                       _it.setOrientation(winnerOrientation)
+                                       _it.init()
+                                       while(_it.isEnd() == 0):
+                                               ve = _it.getObject()
+                                               #print("--------", ve.getId().getFirst(), ve.getId().getSecond())
+                                               self._length = self._length + ve.getLength2D()
+                                               _it.increment()
+                                               if(_it.isBegin() != 0):
+                                                       break;
+                                       _it.setBegin(winner)
+                                       _it.setCurrentEdge(winner)
+                                       _it.setOrientation(winnerOrientation)
+                                       if(_it.isBegin() == 0):
+                                               _it.decrement()
+                                               while ((_it.isEnd() == 0) and (_it.isBegin() == 0)):
+                                                       ve = _it.getObject()
+                                                       #print("--------", ve.getId().getFirst(), ve.getId().getSecond())
+                                                       self._length = self._length + ve.getLength2D()
+                                                       _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.setBegin(winner)
+                               _cit.setCurrentEdge(winner)
+                               _cit.setOrientation(winnerOrientation)
+                               _cit.init()
+                               while((_cit.isEnd() == 0) and (_cit.getObject().qi() != 0)):
+                                       ve = _cit.getObject()
+                                       #print("-------- --------", ve.getId().getFirst(), ve.getId().getSecond())
+                                       connexl = connexl + ve.getLength2D()
+                                       _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=1):
+               ChainingIterator.__init__(self, stayInSelection, 1,None,1)
+       def getExactTypeName(self):
+               return "pyChainSilhouetteIterator"
+       def init(self):
+               pass
+       def traverse(self, iter):
+               winner = None
+               it = AdjacencyIterator(iter)
+               tvertex = self.getVertex()
+               if type(tvertex) is TVertex:
+                       mateVE = tvertex.mate(self.getCurrentEdge())
+                       while(it.isEnd() == 0):
+                               ve = it.getObject()
+                               feB = self.getCurrentEdge().fedgeB()
+                               feA = ve.fedgeA()
+                               vB = feB.vertexB()
+                               vA = feA.vertexA()
+                               if vA.getId().getFirst() == vB.getId().getFirst():
+                                       winner = ve
+                                       break
+                               feA = self.getCurrentEdge().fedgeA()
+                               feB = ve.fedgeB()
+                               vB = feB.vertexB()
+                               vA = feA.vertexA()
+                               if vA.getId().getFirst() == vB.getId().getFirst():
+                                       winner = ve
+                                       break
+                               feA = self.getCurrentEdge().fedgeB()
+                               feB = ve.fedgeB()
+                               vB = feB.vertexB()
+                               vA = feA.vertexB()
+                               if vA.getId().getFirst() == vB.getId().getFirst():
+                                       winner = ve
+                                       break
+                               feA = self.getCurrentEdge().fedgeA()
+                               feB = ve.fedgeA()
+                               vB = feB.vertexA()
+                               vA = feA.vertexA()
+                               if vA.getId().getFirst() == vB.getId().getFirst():
+                                       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.getCurrentEdge().getNature()
+                               if(natures[i] & currentNature):
+                                       count=0
+                                       while(it.isEnd() == 0):
+                                               visitNext = 0
+                                               oNature = it.getObject().getNature()
+                                               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.getObject()
+                                               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..38dd4b7
--- /dev/null
@@ -0,0 +1,92 @@
+from freestyle_init import *
+
+class CurveMaterialF0D(UnaryFunction0DMaterial):
+       # A replacement of the built-in MaterialF0D for stroke creation.
+       # MaterialF0D does not work with Curves and Strokes.
+       def getName(self):
+               return "CurveMaterialF0D"
+       def __call__(self, inter):
+               cp = inter.getObject()
+               assert(isinstance(cp, CurvePoint))
+               fe = cp.A().getFEdge(cp.B())
+               assert(fe is not None)
+               return fe.material() if fe.isSmooth() else fe.bMaterial()
+
+class pyInverseCurvature2DAngleF0D(UnaryFunction0DDouble):
+       def getName(self):
+               return "InverseCurvature2DAngleF0D"
+
+       def __call__(self, inter):
+               func = Curvature2DAngleF0D()
+               c = func(inter)
+               return (3.1415 - c)
+
+class pyCurvilinearLengthF0D(UnaryFunction0DDouble):
+       def getName(self):
+               return "CurvilinearLengthF0D"
+
+       def __call__(self, inter):
+               i0d = inter.getObject()
+               s = i0d.getExactTypeName()
+               if (string.find(s, "CurvePoint") == -1):
+                       print("CurvilinearLengthF0D: not implemented yet for", s)
+                       return -1
+               cp = castToCurvePoint(i0d)
+               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 getName(self):
+               return "pyDensityAnisotropyF0D"
+       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 = pow(2,self._l)
+       def getName(self):
+               return "pyViewMapGradientVectorF0D"
+       def __call__(self, iter):
+               p = iter.getObject().getPoint2D()
+               gx = ReadCompleteViewMapPixelCF(self._l, int(p.x()+self._step), int(p.y()))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+               gy = ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+               return Vector([gx, gy])
+
+class pyViewMapGradientNormF0D(UnaryFunction0DDouble):
+       def __init__(self, l):
+               UnaryFunction0DDouble.__init__(self)
+               self._l = l
+               self._step = pow(2,self._l)
+       def getName(self):
+               return "pyViewMapGradientNormF0D"
+       def __call__(self, iter):
+               p = iter.getObject().getPoint2D()
+               gx = ReadCompleteViewMapPixelCF(self._l, int(p.x()+self._step), int(p.y()))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+               gy = ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()+self._step))- ReadCompleteViewMapPixelCF(self._l, int(p.x()), int(p.y()))
+               grad = 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..aaf1153
--- /dev/null
@@ -0,0 +1,45 @@
+from freestyle_init import *
+from Functions0D import *
+import string 
+
+class pyGetInverseProjectedZF1D(UnaryFunction1DDouble):
+       def getName(self):
+               return "pyGetInverseProjectedZF1D"
+
+       def __call__(self, inter):
+               func = GetProjectedZF1D()
+               z = func(inter)
+               return (1.0 - z)
+
+class pyGetSquareInverseProjectedZF1D(UnaryFunction1DDouble):
+       def getName(self):
+               return "pyGetInverseProjectedZF1D"
+
+       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 getName(self):
+               return "pyDensityAnisotropyF1D"
+       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 getName(self):
+               return "pyViewMapGradientNormF1D"
+       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..3b7d210
--- /dev/null
@@ -0,0 +1,70 @@
+from freestyle_init import *
+from Functions1D import *
+from random import *
+
+class pyZBP1D(BinaryPredicate1D):
+       def getName(self):
+               return "pyZBP1D"
+
+       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 getName(self):
+               return "pyZDiscontinuityBP1D"
+
+       def __call__(self, i1, i2):
+               return (self._GetZDiscontinuity(i1) > self._GetZDiscontinuity(i2))
+
+class pyLengthBP1D(BinaryPredicate1D):
+       def getName(self):
+               return "LengthBP1D"
+
+       def __call__(self, i1, i2):
+               return (i1.getLength2D() > i2.getLength2D())
+
+class pySilhouetteFirstBP1D(BinaryPredicate1D):
+       def getName(self):
+               return "SilhouetteFirstBP1D"
+
+       def __call__(self, inter1, inter2):
+               bpred = SameShapeIdBP1D()
+               if (bpred(inter1, inter2) != 1):
+                       return 0
+               if (inter1.getNature() & Nature.SILHOUETTE):
+                       return (inter2.getNature() & Nature.SILHOUETTE)
+               return (inter1.getNature() == inter2.getNature())
+
+class pyNatureBP1D(BinaryPredicate1D):
+       def getName(self):
+               return "NatureBP1D"
+
+       def __call__(self, inter1, inter2):
+               return (inter1.getNature() & inter2.getNature())
+
+class pyViewMapGradientNormBP1D(BinaryPredicate1D):
+       def __init__(self,l, sampling=2.0):
+               BinaryPredicate1D.__init__(self)
+               self._GetGradient = pyViewMapGradientNormF1D(l, IntegrationType.MEAN)
+       def getName(self):
+               return "pyViewMapGradientNormBP1D"
+       def __call__(self, i1,i2):
+               print("compare gradient")
+               return (self._GetGradient(i1) > self._GetGradient(i2))
+
+class pyShuffleBP1D(BinaryPredicate1D):
+       def __init__(self):
+               BinaryPredicate1D.__init__(self)
+               seed(1)
+       def getName(self):
+               return "pyNearAndContourFirstBP1D"
+
+       def __call__(self, inter1, inter2):
+               r1 = uniform(0,1)
+               r2 = 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..162254f
--- /dev/null
@@ -0,0 +1,103 @@
+from freestyle_init import *
+from Functions0D import *
+
+class pyHigherCurvature2DAngleUP0D(UnaryPredicate0D):
+       def __init__(self,a):
+               UnaryPredicate0D.__init__(self)
+               self._a = a
+                       
+       def getName(self):
+               return "HigherCurvature2DAngleUP0D"
+
+       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 getName(self):
+               return "UEqualsUP0D"
+
+       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 getName(self):
+               return "pyVertexNatureUP0D"
+
+       def __call__(self, inter):
+               v = inter.getObject()
+               nat = v.getNature()
+               if(nat & self._nature):
+                       return 1;
+               return 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 getName(self):
+               return "pyBackTVertexUP0D"
+       def __call__(self, iter):
+               v = iter.getObject()
+               nat = v.getNature()
+               if(nat & Nature.T_VERTEX == 0):
+                       return 0
+               next = iter
+               if(next.isEnd()):
+                       return 0
+               if(self._getQI(next) != 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 getName(self):
+               return "pyCurvilinearAbscissaHigherThanUP0D"
+
+       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 getName(self):
+               return "pyCurvilinearAbscissaHigherThanUP0D"
+
+       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..3529ca8
--- /dev/null
@@ -0,0 +1,381 @@
+from freestyle_init import *
+from Functions1D import *
+
+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 getName(self):
+               return "HigherLengthUP1D"
+
+       def __call__(self, inter):
+               return (inter.getLength2D() > self._l)
+
+class pyNatureUP1D(UnaryPredicate1D):
+       def __init__(self,nature):
+               UnaryPredicate1D.__init__(self)
+               self._nature = nature
+               self._getNature = CurveNatureF1D()
+                       
+       def getName(self):
+               return "pyNatureUP1D"
+
+       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 getName(self):
+               return "HigherNumberOfTurnsUP1D"
+
+       def __call__(self, inter):
+               count = 0
+               func = Curvature2DAngleF0D()
+               it = inter.verticesBegin()
+               while(it.isEnd() == 0):
+                       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 getName(self):
+               return "pyDensityUP1D"
+
+       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 getName(self):
+               return "pyLowSteerableViewMapDensityUP1D"
+
+       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 getName(self):
+               return "pyLowDirectionalViewMapDensityUP1D"
+
+       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 getName(self):
+               return "pyHighSteerableViewMapDensityUP1D"
+
+       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 getName(self):
+               return "pyLowDirectionalViewMapDensityUP1D"
+
+       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 getName(self):
+               return "pyHighViewMapDensityUP1D"
+
+       def __call__(self, inter):
+               #print("toto")
+               #print(func.getName())
+               #print(inter.getExactTypeName())
+               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 getName(self):
+               return "pyDensityFunctorUP1D"
+
+       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 getName(self):
+               return "pyZSmallerUP1D"
+
+       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 getName(self):
+               return "pyIsOccludedByUP1D"
+       def __call__(self, inter):
+               func = GetShapeF1D()
+               shapes = func(inter)
+               for s in shapes:
+                       if(s.getId() == self._id):
+                               return 0
+               it = inter.verticesBegin()
+               itlast = inter.verticesEnd()
+               itlast.decrement()
+               v =  it.getObject()
+               vlast = itlast.getObject()
+               tvertex = v.viewvertex()
+               if type(tvertex) is TVertex:
+                       print("TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]")
+                       eit = tvertex.edgesBegin()
+                       while(eit.isEnd() == 0):
+                               ve, incoming = eit.getObject()
+                               if(ve.getId() == self._id):
+                                       return 1
+                               print("-------", ve.getId().getFirst(), "-", ve.getId().getSecond())
+                               eit.increment()
+               tvertex = vlast.viewvertex()
+               if type(tvertex) is TVertex:
+                       print("TVertex: [ ", tvertex.getId().getFirst(), ",",  tvertex.getId().getSecond()," ]")
+                       eit = tvertex.edgesBegin()
+                       while(eit.isEnd() == 0):
+                               ve, incoming = eit.getObject()
+                               if(ve.getId() == self._id):
+                                       return 1
+                               print("-------", ve.getId().getFirst(), "-", ve.getId().getSecond())
+                               eit.increment()
+               return 0
+
+class pyIsInOccludersListUP1D(UnaryPredicate1D):
+       def __init__(self,id):
+               UnaryPredicate1D.__init__(self)
+               self._id = id
+       def getName(self):
+               return "pyIsInOccludersListUP1D"
+       def __call__(self, inter):
+               func = GetOccludersF1D()
+               occluders = func(inter)
+               for a in occluders:
+                       if(a.getId() == self._id):
+                               return 1
+               return 0
+
+class pyIsOccludedByItselfUP1D(UnaryPredicate1D):
+       def __init__(self):
+               UnaryPredicate1D.__init__(self)
+               self.__func1 = GetOccludersF1D()
+               self.__func2 = GetShapeF1D()
+       def getName(self):
+               return "pyIsOccludedByItselfUP1D"
+       def __call__(self, inter):
+               lst1 = self.__func1(inter)
+               lst2 = self.__func2(inter)
+               for vs1 in lst1:
+                       for vs2 in lst2:
+                               if vs1.getId() == vs2.getId():
+                                       return 1
+               return 0
+
+class pyIsOccludedByIdListUP1D(UnaryPredicate1D):
+       def __init__(self, idlist):
+               UnaryPredicate1D.__init__(self)
+               self._idlist = idlist
+               self.__func1 = GetOccludersF1D()
+       def getName(self):
+               return "pyIsOccludedByIdListUP1D"
+       def __call__(self, inter):
+               lst1 = self.__func1(inter)
+               for vs1 in lst1:
+                       for id in self._idlist:
+                               if vs1.getId() == 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.getFirst(), id.getSecond()))
+               
+       def getName(self):
+               return "pyShapeIdUP1D"
+       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 getName(self):
+               return "pyShapeIdUP1D"
+       def __call__(self, inter):
+               func = GetShapeF1D()
+               shapes = func(inter)
+               for a in shapes:
+                       if(a.getId() == 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 getName(self):
+               return "pyHighDensityAnisotropyUP1D"
+       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 getName(self):
+               return "pyHighViewMapGradientNormUP1D"
+       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 getName(self):
+               return "pyDensityUP1D"
+
+       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.verticesBegin()
+               itlast = inter.verticesEnd()
+               itlast.decrement()      
+               vlast = itlast.getObject()
+               v = it.getObject()
+               print(v.getId().getFirst(), v.getId().getSecond())
+               print(vlast.getId().getFirst(), vlast.getId().getSecond())
+               if(v.getId() == vlast.getId()):
+                       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..83cc999
--- /dev/null
@@ -0,0 +1,47 @@
+#
+#  Filename : anisotropic_diffusion.py
+#  Author   : Fredo Durand
+#  Date     : 12/08/2004
+#  Purpose  : Smoothes lines using an anisotropic diffusion scheme
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from shaders import *
+
+# pyDiffusion2Shader parameters
+offset = 0.25
+nbIter = 30
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select( upred )
+bpred = TrueBP1D()
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(upred) )
+shaders_list = [
+    ConstantThicknessShader(4),
+    StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, 0),
+    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..7cdd4b2
--- /dev/null
@@ -0,0 +1,45 @@
+#
+#  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
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.3, IntegrationType.LAST))
+Operators.select(upred)
+bpred = TrueBP1D()
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list =         [
+               ConstantThicknessShader(2), 
+               ConstantColorShader(0.0, 0.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..5ff6c58
--- /dev/null
@@ -0,0 +1,43 @@
+#
+#  Filename : apriori_density.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws lines having a high a priori density
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.1,5)))
+bpred = TrueBP1D()
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), pyHighViewMapDensityUP1D(0.0007,5))
+Operators.bidirectionalChain(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..8a6b9d7
--- /dev/null
@@ -0,0 +1,36 @@
+#
+#  Filename : backbone_stretcher.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Stretches the geometry of visible lines
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(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..7f3a756
--- /dev/null
@@ -0,0 +1,46 @@
+#
+#  Filename : blueprint_circles.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using circular contour strokes
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectionalChain(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..a5cfe4e
--- /dev/null
@@ -0,0 +1,46 @@
+#
+#  Filename : blueprint_ellipses.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using elliptic contour strokes
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectionalChain(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..7798acc
--- /dev/null
@@ -0,0 +1,45 @@
+#  Filename : blueprint_squares.py
+#  Author   : Emmanuel Turquin
+#  Date     : 04/08/2005
+#  Purpose  : Produces a blueprint using square contour strokes
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+bpred = SameShapeIdBP1D()
+Operators.select(upred)
+Operators.bidirectionalChain(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..6ace7e0
--- /dev/null
@@ -0,0 +1,42 @@
+#
+#  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.
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(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..c4b3a0f
--- /dev/null
@@ -0,0 +1,42 @@
+#
+#  Filename : contour.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws each object's visible contour
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+
+Operators.select(AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D() ) )
+bpred = SameShapeIdBP1D();
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ContourUP1D())
+Operators.bidirectionalChain(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..0c01399
--- /dev/null
@@ -0,0 +1,40 @@
+#
+#  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
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(), NotUP1D(QuantitativeInvisibilityUP1D(0)))
+shaders_list = [
+    StrokeTextureShader("smoothAlpha.bmp", Stroke.OPAQUE_MEDIUM, 0),
+    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..2a39b79
--- /dev/null
@@ -0,0 +1,43 @@
+#
+#  Filename : external_contour.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws the external contour of the scene
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from ChainingIterators import *
+from shaders import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred )
+bpred = TrueBP1D();
+Operators.bidirectionalChain(ChainPredicateIterator(upred, bpred), NotUP1D(upred))
+shaders_list =         [
+               ConstantThicknessShader(3),
+               ConstantColorShader(0.0, 0.0, 0.0,1)
+               ]
+Operators.create(TrueUP1D(), shaders_list)
\ No newline at end of file
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..8a4c570
--- /dev/null
@@ -0,0 +1,48 @@
+#
+#  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
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+
+from freestyle_init import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D()) 
+Operators.select(upred)
+Operators.bidirectionalChain(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..201dc27
--- /dev/null
@@ -0,0 +1,44 @@
+#
+#  Filename : external_contour_smooth.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws a smooth external contour
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+from freestyle_init import *
+from logical_operators import *
+from PredicatesB1D import *
+from PredicatesU1D import *
+from shaders import *
+from ChainingIterators import *
+
+upred = AndUP1D(QuantitativeInvisibilityUP1D(0), ExternalContourUP1D())
+Operators.select(upred)
+bpred = TrueBP1D();
+Operators.bidirectionalChain(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/extra-lines.sml b/release/scripts/freestyle/style_modules/extra-lines.sml
new file mode 100644 (file)
index 0000000..c63cd40
--- /dev/null
@@ -0,0 +1,3 @@
+1suggestive.py
+1ridges.py
+1nor_suggestive_or_ridges.py
diff --git a/release/scripts/freestyle/style_modules/freestyle_init.py b/release/scripts/freestyle/style_modules/freestyle_init.py
new file mode 100644 (file)
index 0000000..9eb8b2d
--- /dev/null
@@ -0,0 +1,2 @@
+from Freestyle import *
+from mathutils import Vector
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..afa4617
--- /dev/null
@@ -0,0 +1,50 @@
+#
+#  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
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesB1D import *
+from shaders import *
+
+# 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.bidirectionalChain(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..ff6efa8
--- /dev/null
@@ -0,0 +1,41 @@
+#
+#  Filename : ignore_small_oclusions.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : The strokes are drawn through small occlusions
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+#Operators.bidirectionalChain(pyFillOcclusionsChainingIterator(0.1))
+Operators.bidirectionalChain(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..ea50946
--- /dev/null
@@ -0,0 +1,42 @@
+#
+#  Filename : invisible_lines.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Draws all lines whose Quantitative Invisibility 
+#             is different from 0
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from ChainingIterators import *
+from shaders import *
+
+upred = NotUP1D(QuantitativeInvisibilityUP1D(0))
+Operators.select(upred)
+Operators.bidirectionalChain(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..7f10959
--- /dev/null
@@ -0,0 +1,60 @@
+#
+#  Filename : japanese_bigbrush.py
+#  Author   : Stephane Grabli
+#  Date     : 04/08/2005
+#  Purpose  : Simulates a big brush fr oriental painting
+#
+#############################################################################  
+#
+#  Copyright (C) : Please refer to the COPYRIGHT file distributed 
+#  with this source distribution. 
+#
+#  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+#############################################################################
+
+from freestyle_init import *
+from logical_operators import *
+from PredicatesU1D import *
+from PredicatesB1D import *
+from Functions0D import *
+from shaders import *
+
+Operators.select(QuantitativeInvisibilityUP1D(0))
+Operators.bidirectionalChain(ChainSilhouetteIterator(),NotUP1D(QuantitativeInvisibilityUP1D(0)))
+## Splits strokes at points of highest 2D curavture 
+## when there are too many abrupt turns in it
+func = pyInverseCurvature2DAngleF0D()
+Operators.recursiveSplit(func,  pyParameterUP0D(0.2,0.8), NotUP1D(pyHigherNumberO