[Soiltexture-commits] r19 - pkg/soiltexture/R

noreply at r-forge.r-project.org noreply at r-forge.r-project.org
Tue Jun 1 16:46:33 CEST 2010


Author: jmoeys
Date: 2010-06-01 16:46:33 +0200 (Tue, 01 Jun 2010)
New Revision: 19

Added:
   pkg/soiltexture/R/soiltexture.R
Log:
Step 2 of renaming soiltexture.r into soiltexture.R (needed by inlinedocs)

Added: pkg/soiltexture/R/soiltexture.R
===================================================================
--- pkg/soiltexture/R/soiltexture.R	                        (rev 0)
+++ pkg/soiltexture/R/soiltexture.R	2010-06-01 14:46:33 UTC (rev 19)
@@ -0,0 +1,6749 @@
+# source( "C:/_RTOOLS/SWEAVE_WORK/SOIL_TEXTURES/rforge/pkg/soiltexture/R/soiltexture.r" ) 
+# source( "http://r-forge.r-project.org/scm/viewvc.php/*checkout*/pkg/soiltexture/R/soiltexture.r?root=soiltexture" ) 
+# +-------------------------------------------------------------------------+
+# |                                                                         |
+# | Julien MOEYS                                                            |
+# |                                                                         |
+# | The Soil Texture Wizard -- A set of R functions to plot soil texture    |
+# | triangles, classify and transform soil texture data                     |
+# |                                                                         |
+# | These functions are _originally_ based on the soil.texture function,    |
+# | in the PLOTRIX package from Jim LEMON and Ben BOLKER. But the code has  |
+# | been gradually modified, and is now (ALMOST?) ENTIRELY DIFFERENT from   |
+# | the original code. Not compatibilty has been maintained with PLOTRIX    |
+# | see <http://cran.r-project.org/web/packages/plotrix/index.html>         |
+# |                                                                         |
+# | Author:             -   Moeys Julien (2006-2010)                        |
+# | Contact:                http://julienmoeys.free.fr                      |
+# |                                                                         |
+# | Original sources:   -   plotrix package, by Lemon J. and Bolker B.      |
+# |                                                                         |
+# | Institution:            < 2008: EGC                                     |
+# |                                 UMG Environnement et Grandes Cultures   |
+# |                                 Equipe Sol, INRA/AgroParisTech          |
+# |                                 av. Lucien Bretignre, BP01              |
+# |                                 F-78850, Thiverval-Grignon, FRANCE      |
+# |                         > 2008: SLU Swedish University of               |
+# |                                 Agricultural Sciences                   |
+# |                                 Soil Science dept.,                     |
+# |                                 Environmental Physics div.              |
+# |                                 Ulls vg 17, Ultuna - PO Box 7014        |
+# |                                 SE-75651 Uppsala, SWEDEN                |
+# |                                                                         |
+# | None of the institution above, and neither the author, endorse any      |
+# | responsibility for problems that could arise from inaccuracies or errors|
+# | in the code presented here. (1) It is much based on free personal work  |
+# | and (2) it is provided for free, so users have the responsibility to    |
+# | check themselves that the program works as expected...                  |
+# |                                                                         |
+# | Research program:       An awful lots of _personal_ work +              |
+# | Research program:       < 2008: ESHEL research program,                 |
+# | Research program:       < 2009: FOOTPRINT, EU-FP6-funded project        |
+# |                                                                         |
+# | Context:                PhD thesis (France)                             |
+# |                         Post-doctoral position (Sweden)                 |
+# |                                                                         |
+# | Copyleft:               Julien Moeys                                    |
+# | Licence:                General Public Licence, GPL (>=3)               |
+# |                                                                         |
+# | Programing language:    R language for statistical computing            |
+# |                         http://wwww:r-project.org                       |
+# | OS:                     Tested on Windows XP                            |
+# |                         this scripts may/should work on Linux and MacOS |
+# |                                                                         |
+# +-------------------------------------------------------------------------+
+# |                                                                         |
+# | FEATURES list:                                                          |
+# | -   Create ternary/triangle plot of point variables defined by a        |
+# |     triplet of variable (which sum to a constant).                      |
+# |     -   Default settings for Soil Texture Triangle Plots                |
+# |     -   Capable of displaying 4 FAMILIES/TYPES of ternary plots         |
+# |         (1) Equilateral with clockwise axis                             |
+# |         (2) Equilateral with counter-clockwise axis                     |
+# |         (3) Right-triangle, with right-side 90deg angle, base side      |
+# |             counter-clockwise and right side clockwise                  |
+# |         (4) Right-triangle, with left-side 90deg angle, base side       |
+# |             clockwise and right left counter-clockwise                  |
+# |     -   For all families, triangle internal angles fully customizable,  |
+# |         a fancy feature for creating free form ternary plot             |
+# |     -   Free variable sum (1, 100 or X) for the ternary plot;           |
+# | -   Display variable-classes polygons/area on the ternary plot;         |
+# |     -   7 pre-parameterized national Soil Texture Triangles/Classes     |
+# |         systems, including classes polygons, classes and axis names,    |
+# |         and geometric settings of the triangle.                         |
+# |         (FAO, USDA, French-Aisne, French-GEPPA, German, UK and          |
+# |         Australian triangles)                                           |
+# |     -   Capable of projecting any Soil Texture Triangles/Classes systems|
+# |         in another family of ternary plot (custom angles and clock),    |
+# |         thus enabling otherwise difficult comparisons of systems        |
+# | -   Retrieve the class(es) of point data in a given (Soil Texture)-     |
+# |     class system (pre-defined)                                          |
+# | -   Several features for exploratory/visual analysis                    |
+# |     -   Create a background 2d map of a 4th variable (heat-map),        |
+# |         through inverse weighted distance grid-interpolation            |
+# | -   Global (and triangle-specific) parameters management system, with   |
+# |     functions for easily retrieving and changing these options          |
+# | -   Simple pre-defined Bubble & color-gradient plot for a 4th variable  |
+# | -   Linguistic components ('local' variable names)                      |
+# | -   A generic function for checking "sum of variable triplets"          |
+# | -   'geo' global and triangle specific option, that is outputted either |
+# |     from TT.plot() or TT.frame() and is used by lower level plotting    |
+# |     functions: frame, grid, arrows, points...                           |
+# |     (Parameters: tlr.an, blr.clock, blr.tx, text.sum, etc)              |
+# |                                                                         |
+# +-------------------------------------------------------------------------+
+
+
+
+# +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+# | LOAD REQUIRED PACKAGES: sp          |
+# +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+# [ sp package is required for his pointinpolygon() function 
+#   it is used here to determine is a data-point belong to a class-polygon (Soil Texture Class) 
+# if( !"sp" %in% as.character( installed.packages()[,1] ) )
+# {   #
+#     install.packages("sp")
+# }   #
+
+require( "sp" )
+
+
+
+# +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+# | ENV: TT.env()                       |
+# +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+# [ TT.env() :: environment for storing, hiding and protecting internal variables and functions
+TT.env <- new.env()
+# TT.env
+
+
+
+# +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+# | LIST: TT.par                        |
+# +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+# [ TT.par :: A list of default parameters, contained in a list, stored in the TT.env environment (~ invisible)
+assign( 
+    envir   = TT.env,
+    x       = "TT.par", 
+    value   = list( 
+        # +-------------------------------------------------------------------------+
+        # | SCRIPT PARAMETERS SPECIFICATION:                                        |
+        # +-------------------------------------------------------------------------+
+        #
+        # +---------------------------------+
+        # | TRIANGLE GEOMETRY               |
+        # +---------------------------------+
+        #
+        # Geometry of the texture triangle, in cases where no specific texture triangle 
+        #   is used. Be aware that some of these default parameters will be overwritten 
+        #   by triangle specific parameters.
+        blr.clock       = rep(T,3), # clockwise axes (T) ? or counterclock ? (F)
+                                    #   clock wise mean bottom axis is oriented from right to left, 
+                                    #   left axis is oriented bottom to top and right axis is 
+                                    #   oriented from top to bottom.
+                                    #   Can also be c(F,T,NA) or c(T,NA,F) or c(NA,F,T)
+        # Top, Left and Right ANGLES of the triangle, in DEGREES
+        tlr.an          = c(60,60,60), 
+                                    #   For nicer triangle, higher angle must be on the LEFT in the case
+                                    #   of a clock orientation, and higher angle must be on the RIGHT 
+                                    #   in the case of a counter-clock orientation
+                                    # Bottom, Left and Right TEXTURES of the triangles
+        # 
+        # NB: in the default options, coordinates are always expressed as a "fraction" (0 to 1 values)
+        # 
+        # Limits of the triangle to be drawn (get rid of this???)
+        base.frame      = data.frame( 
+            # Rows (here vertical)      = triangle submits
+            # Coulmns (here horizontal) = coordinates of the submits for bootom, left and right variables 
+            "b" = c( 1, 0, 0 ), 
+            "l" = c( 0, 1, 0 ), 
+            "r" = c( 0, 0, 1 ) 
+        ),  #
+        # 
+        # Limits (min,max values) of the different variables
+        b.lim           = c(0,1),   # Bootom variable
+        l.lim           = c(0,1),   # Left   variable
+        r.lim           = c(0,1),   # Right  variable
+        # 
+        # Limits "tolerance", as a fraction of the triangle maximum range (0 to 1)
+        lim.tol         = 0.1, 
+        # 
+        # +---------------------------------+
+        # | TRIANGLE BASE CONTENT           |
+        # +---------------------------------+
+        # See also pre-formatted triangles with classe below
+        #
+        # Bottom, Left and Right TeXtures (= which texture 
+        #   displaying on B, L, R axis). MUST belong to CLAY SILT 
+        #   and SAND (the order is free).
+        blr.tx          = c("SAND","CLAY","SILT"), 
+        # 
+        # Clay, Silt and Sand (columns) NAMES in the input soil 
+        #   texture data table (tri.data). 
+        #   example: c("ARGILE","LIMON","SABLE") 
+        css.names       = c("CLAY","SILT","SAND"), 
+        #
+        # A vector of 3 character strings, or expressions, for the 
+        #   LABELS of Clay, Silt and Sand, respectively. If 
+        #   non-null, will overwrite any default label (in any lang).
+        css.lab         = NULL, 
+        #
+        #blr.lab         = NULL,     # a vector of 3 character strings 
+        #                           # or expressions, with the labels 
+        #                           # of bottom, left and right axis.
+        #
+        lang            = "en", 
+        #
+        # blr.psize.lim = data.frame( 
+        #   "SAND"  = c(50,2000), 
+        #   "CLAY"  = c(0,2), 
+        #   "SILT"  = c(2,50) 
+        # ),    #
+        # 
+        unit.ps         = quote(bold(mu) * bold('m')), 
+        unit.tx         = quote(bold('%')), 
+        #
+        # Input data:
+        text.sum        = 100,      # Value of the SUM OF CLAY SILT SAND TEXTURE: either 1 or 100 (or fancy)
+        text.tol        = 1/1000,   # Error tolerance on the sum of the 3 texture classes
+        tri.sum.tst     = TRUE,     # Perform a sum test on the tri-variable data (sums == text.sum) ??
+        tri.pos.tst     = TRUE,     # Test if all tri-variable data are positive ??
+        # 
+        # +---------------------------------+
+        # | INTERNATIONALISATION            |
+        # +---------------------------------+
+        lang.par    = data.frame( 
+            "lang"  = c(    "en",                           "fr",                       "it", 
+                            "es",                           "de",                       "nl",
+                            "se",                           "fl"        ), ##
+            #
+            "CLAY"  = c(    "\"Clay\"",                     "\"Argile\"",               "\"Argilla\"", 
+                            "\"Arcilla\"",                  "\"Ton\"",                  "\"Lutum\"", 
+                            "\"Ler\"",                      "\"Klei\""  ), ##
+            #
+            "SILT"  = c(    "\"Silt\"",                     "\"Limon\"",                "\"Limo\"", 
+                            "\"Limo\"",                     "\"Schluff\"",              "\"Silt\"", 
+                            "\"Silt\"",                     "\"Leem\""  ), ##
+            #
+            "SAND"  = c(    "\"Sand\"",                     "\"Sable\"",                "\"Sabbia\"", 
+                            "\"Arena\"",                    "\"Sand\"",                 "\"Zand\"", 
+                            "\"Sand\"",                     "\"Zand\""  ), ##
+            #
+            "TT"    = c(    "\"Texture triangle\"",         "\"Triangle de texture\"",  "\"Triangolo della tessitura\"", 
+                            "\"Tri\\340ngulo de textura\"", "\"Bodenartendiagramm\"",   "\"Textuurdriehoek\"", 
+                            "\"Texturtriangel\"",           "\"Textuurdriehoek\""  ), ##
+            stringsAsFactors    = FALSE  
+        ),  #
+        # 
+        # +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+        # | TRIANGLE CUSTOMISATION          |
+        # +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+        # 
+        # +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+        # | General graphical parameters
+        # 
+        # FONTS:
+        font            = NULL,     # for plotted points and text
+        font.axis       = 2,        # for ticks labels
+        font.lab        = 2,        # for axis labels (arrows) and texture classes labels
+        font.main       = 2,        # main title 
+        # 
+        # COLORS:
+        bg              = NULL,     # plot and plotted points background
+        fg              = NULL,     # for plotted points and text (foreground) 
+        col             = NULL,     # for plotted points and text 
+        col.axis        = NULL,     # for ticks, triangle "axis/frame" (but not texture classes or grid)
+        col.lab         = NULL,     # for axis labels and arrows (but not texture classes labels)
+        col.main        = NULL,     # main title 
+        # NOTICE: grid lines and "frame" background colors are set with other options (non generic)
+        # 
+        # CEX:
+        cex             = 1.5,      # for plotted points and text 
+        cex.axis        = 1.5,      # for ticks labels
+        cex.lab         = 1.5,      # for axis labels and texture classes labels
+        cex.main        = 1.5,      # main title 
+        # 
+        # LWD: 
+        lwd             = 3,        # for plotted lines (not implemented yet?) 
+        #
+        #
+        #
+        # warning. belw, not in par()
+        lwd.axis        = 3,        # for ticks, triangle "axis/frame" and grid
+        lwd.lab         = 3,        # for axis arrows and texture classes polygons
+        # 
+        # FAMILY: 
+        family.op       = NULL, 
+        #
+        # graph margins (as in par("mar")):
+        new.mar         = NULL, 
+        #
+        # +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+
+        # | Specific graphical parameters
+        #
+        # TRIANGLE FRAME parameters:
+        frame.bg.col    = NULL,             # triangle frame background color
+        #
+        # Texture values _at_ which starting grid or thicks points (values between 0 and 1!!!)
+        at              = seq(from=.1,to=.9,by=.1), 
+        # 
+        # CLASSES SYSTEM (polygons / Texture Triangle) used by default:
+        class.sys       = "FAO50.TT", 
+        class.lab.col   = NULL,             # Color of classes names (abreviation)
+        class.p.bg.col  = FALSE,            # Fill classes polygon with color gradient ???
+        class.p.bg.hue  = 0.04,             # Hue (unique) of the classes polygon color gradient
+        class.line.col  = NULL,             # Classes lines (foreground) color
+        #                                   # 0.04 is salmon-pink, 0.21 is olive green, 0.57 is sky blue, 0.72 a nice purple-blue
+        class.lty       = NULL, 
+        class.lab.show  = "abr",            # Show
+        #
+        # GRID LINES parameters:
+        grid.show       = TRUE, 
+        grid.col        = NULL,             # grid line colors (fg) # default in fact gray(.5)
+        grid.lty        = 1,                # Grid line type
+        #
+        # TICKS MARK parameters:
+        ticks.shift         = 02.5/100,     # Value of the ticks shift from the border of the triangle: ]0;1[ (but 1 extra big)
+        ticks.lab.shift     = 05.0/100,     # Value of the ticks label shift from the border of the triangle: ]0;1[ (but 1 extra big) 
+        #
+        # ARROWS parameters:
+        arrows.show         = TRUE, 
+        arrows.lims         = c(0.150,0.450), 
+        arrows.head.shift   = 05.0/100,     # Distance between the arrow head and the triangle frame
+        arrows.base.shift   = 11.0/100,     # Distance between the arrow base and the triangle frame
+        arrows.text.shift   = 11.0/100,     # Distance between the arrow label/text and the triangle frame
+        arrows.text.shift2  = 10.0/100,     # Distance between the arrow "turn" and the text (parallel to axis)
+        arrows.lty          = 1, 
+        #
+        # POINTS-DATA parameters:
+        points.type         = "p", 
+        pch                 = NULL,  # Added 20090617 
+        # 
+        # TEXT DATA parameters:
+        adj             = c(0.5,0.5), 
+        pos             = NULL, 
+        offset          = 0, 
+        #
+        # +---------------------------------+
+        # | TT.points.in.classes parameters |
+        # +---------------------------------+
+        PiC.type            = c("n","l","t")[1], 
+        #                                   # Type of output for TT.points.in.classes
+        #                                   # "n" stands for numeric (0 = out, 1 = in, 3 = border) 
+        #                                   # "l" stands for logical (F = out, T = in) 
+        #                                   # "t" stands for text (concatenated texture class symbol)
+        # 
+        # +---------------------------------+
+        # | z: the 4th variable             |
+        # +---------------------------------+
+        # [ z may be plotted as a bubble chart or as an interpolated map
+        z.type              = c("bubble","map")[1], 
+        z.col.hue           = 0.21, 
+        z.cex.range         = c(1.00,4.00), 
+        # z.cex.min         = 0.50, 
+        z.pch               = c(16,1),  # Respectively for color fill and border
+        #
+        # +---------------------------------+
+        # | Texture particle size           |
+        # | transformation:                 |
+        # +---------------------------------+ 
+        # Base (plot, geometry, reference) Clay Silt Sand 
+        #   particle size limits (in micro-meters), in the form of 
+        #   c(clay min,clay max = silt min, silt max = sand min, sand.max) 
+        #   If plotted texture triangles or soil point data have 
+        #   a different css.ps.lim, and if transformation is allowed, 
+        #   then all Clay Silt Sand data will be coverted TO that 
+        #   system.
+        base.css.ps.lim = c(0,2,50,2000), 
+        #
+        # Same, but for the plotted texture triangle
+        #   particle size limits (in micro-meters) (see above)
+        tri.css.ps.lim  = NULL, 
+        #
+        # Same, but for the plotted soil point data (tri.data)
+        #   particle size limits (in micro-meters) (see above)
+        dat.css.ps.lim  = NULL, 
+        # 
+        # Should any texture triangle or soil point data, with 
+        #   different Clay Silt Sand particle size limits from the 
+        #   base plot, be transformed into the base plot system?
+        css.transf      = FALSE, 
+        #
+        # Default function to be used when transforming soil 
+        #   texture data or triangles (particle sizes) 
+        #   alternatives functions should either have the same 
+        #   options (even if some are not used), or a "..." option 
+        #   that will be used as a "dump" for unused otions.
+        text.transf.fun     = "TT.text.transf",  # CHARACTER vector
+        #
+        # In case an alternative to "TT.text.transf" is used in 
+        #   text.transf.fun, it is possible to provide 2 additional 
+        #   options to that new functions (free), unused in 
+        #   "TT.text.transf".
+        trsf.add.opt1       = NA,   # Additionnal option 1 
+        trsf.add.opt2       = NA,   # Additionnal option 2 
+        #
+        # +---------------------------------+
+        # | HYPRES TEXTURE TRIANGLE         |
+        # +---------------------------------+
+        #
+        FAO50.TT  = list( # FAO TRIANGLE PARAMETERS :
+            #
+            main            = "FAO/HYPRES", 
+            # 
+            #                 The list below specify the CSS coordinates of the different POINTS
+            #                   that are used to draw soil texture classes. One points can be 
+            #                   used by several classes :
+            #                  =-P01-   P02    P03    P04    P05    P06    P07    P08   -P09-   P10    P11   -P12-    
+            "tt.points"     = data.frame( 
+                "CLAY"      = c( 1.000, 0.600, 0.600, 0.350, 0.350, 0.350, 0.180, 0.180, 0.000, 0.000, 0.000, 0.000), 
+                "SILT"      = c( 0.000, 0.000, 0.400, 0.000, 0.500, 0.650, 0.000, 0.170, 0.000, 0.350, 0.850, 1.000), 
+                "SAND"      = c( 0.000, 0.400, 0.000, 0.650, 0.150, 0.000, 0.820, 0.650, 1.000, 0.650, 0.150, 0.000)  
+            ),  #
+            #
+            #   Abreviations;       Names of the texture cl;    Points marking the class limits (points specified above)
+            "tt.polygons"   = list( 
+                "VF"        = list( "name" = "Very fine",       "points" = c(02,01,03)          ), 
+                "F"         = list( "name" = "Fine",            "points" = c(04,02,03,06)       ), 
+                "M"         = list( "name" = "Medium",          "points" = c(07,04,05,11,10,08) ), 
+                "MF"        = list( "name" = "Medium fine",     "points" = c(11,05,06,12)       ), 
+                "C"         = list( "name" = "Coarse",          "points" = c(09,07,08,10)       )  
+            ),  #
+            #
+            # Traingle specific parameters for triangle geometry / appearance
+            #   See general parameters above for detailed description of them
+            blr.clock       = rep(T,3), 
+            tlr.an          = c(60,60,60), 
+            #
+            blr.tx      = c("SAND","CLAY","SILT"), 
+            # 
+            base.css.ps.lim = c(0,2,50,2000), 
+            tri.css.ps.lim  = c(0,2,50,2000), 
+            #
+            unit.ps         = quote(bold(mu) * bold('m')), 
+            unit.tx         = quote(bold('%')), 
+            #
+            text.sum        = 100 
+            #
+            # In fact it is the FAO soil texture classes: Info from SysCan
+            # http://sis.agr.gc.ca/cansis/nsdb/lpdb/faotext.html
+            # FAO Soil Texture
+            # Texture is the relative proportion of sand, silt and clay of the dominant 
+            # soil for each soil map polygon. Texture classes are:
+            #
+            # Coarse texture: sands, loamy sand and sandy loams with less than 18 % clay, 
+            # and more than 65 % sand.
+            #
+            # Medium texture: sandy loams, loams, sandy clay loams, silt loams with less 
+            # than 35 % clay and less than 65 % sand; the sand fractions may be as high as 82 % if a minimum of 18 % clay is present.
+            #
+            # Fine texture: clays, silty clays, sandy clays, clay loams and silty clay loams 
+            # with more than 35 % clay.
+            #
+            # Where two or three texture names appear, this means that all named textures 
+            # are present in the map unit.
+            # 
+            # Texture Codeset
+            # COARSE
+            # FINE
+            # FINE-COARSE
+            # FINE-MED-CRS
+            # FINE-MEDIUM
+            # MEDIUM
+            # MEDIUM-COARSE
+            #
+        ),  #
+        #
+        USDA.TT = list(  #  USDA Triangle parameters
+            #
+            main            = "USDA", 
+            # 
+            #                The list below specify the CSS coordinates of the different POINTS
+            #                   that are used to draw soil texture classes. One points can be 
+            #                   used by several classes :
+            #                  = P01    P02    P03    P04    P05    P06    P07    P08    P09    P10    P11    P12
+            #                  = P13    P14    P15    P16    P17    P18    P19    P20    P21    P22    P23   
+            #                  = P24    P25    P26 (submits)
+            "tt.points"     = data.frame( 
+                "CLAY"      = c( 0.550, 0.600, 0.350, 0.350, 0.400, 0.400, 0.400, 0.200, 0.200, 0.275, 0.275, 0.275,  
+                                 0.275, 0.150, 0.100, 0.075, 0.075, 0.125, 0.125, 0.000, 0.000, 0.000, 0.000,         
+                                 1.000, 0.000, 0.000  ),  
+                            #
+                "SILT"      = c( 0.000, 0.400, 0.000, 0.200, 0.150, 0.400, 0.600, 0.000, 0.275, 0.275, 0.500, 0.525,  
+                                 0.725, 0.000, 0.000, 0.400, 0.500, 0.800, 0.875, 0.150, 0.300, 0.500, 0.800,         
+                                 0.000, 0.000, 1.000  ),  
+                            #
+                "SAND"      = c( 0.450, 0.000, 0.650, 0.450, 0.450, 0.200, 0.000, 0.800, 0.525, 0.450, 0.225, 0.200,  
+                                 0.000, 0.850, 0.900, 0.525, 0.425, 0.075, 0.000, 0.850, 0.700, 0.500, 0.200,         
+                                 0.000, 1.000, 0.000  )  
+            ),  #
+            #
+            #   Abreviations;       Names of the texture cl;    Points marking the class limits (points specified above)
+            "tt.polygons"   = list( 
+                "Cl"        = list( "name" = "clay",            "points" = c(24,01,05,06,02)            ), 
+                "SiCl"      = list( "name" = "silty clay",      "points" = c(02,06,07)                  ), 
+                "SaCl"      = list( "name" = "sandy clay",      "points" = c(01,03,04,05)               ), 
+                "ClLo"      = list( "name" = "clay loam",       "points" = c(05,04,10,11,12,06)         ), 
+                "SiClLo"    = list( "name" = "silty clay loam", "points" = c(06,12,13,07)               ), 
+                "SaClLo"    = list( "name" = "sandy clay loam", "points" = c(03,08,09,10,04)            ), 
+                "Lo"        = list( "name" = "loam",            "points" = c(10,09,16,17,11)            ), 
+                "SiLo"      = list( "name" = "silty loam",      "points" = c(11,17,22,23,18,19,13,12)   ), 
+                "SaLo"      = list( "name" = "sandy loam",      "points" = c(08,14,21,22,17,16,09)      ), 
+                "Si"        = list( "name" = "silt",            "points" = c(18,23,26,19)               ), 
+                "LoSa"      = list( "name" = "loamy sand",      "points" = c(14,15,20,21)               ), 
+                "Sa"        = list( "name" = "sand",            "points" = c(15,25,20)                  )  
+            ),  #
+            #
+            # Triangle specific parameters for triangle geometry / appearance
+            #   See general parameters above for detailed description of them
+            blr.clock       = rep(T,3), 
+            tlr.an          = c(60,60,60), 
+            #
+            blr.tx      = c("SAND","CLAY","SILT"), 
+            # 
+            base.css.ps.lim = c(0,2,50,2000), 
+            tri.css.ps.lim  = c(0,2,50,2000), 
+            #
+            unit.ps         = quote(bold(mu) * bold('m')), 
+            unit.tx         = quote(bold('%')), 
+            #
+            text.sum        = 100 
+        ),  #
+        # 
+        FR.AISNE.TT = list( # AISNE/FRENCH TRIANGLE PARAMETERS :
+            #
+            main            = "Aisne (FR)", 
+            #
+            #                 The list below specify the CSS coordinates of the different POINTS
+            #                   that are used to draw soil texture classes. One points can be 
+            #                   used by several classes :
+            #                  = P01    P02    P03    P04    P05    P06    P07    P08    P09    P10    P11    
+            #                    P12    P13    P14    P15    P16    P17    P18   -P19-   P20    P21    P22    
+            #                    P23    P24    P25    P26   -P27-  -P28-   P29    
+            "tt.points"     = data.frame( 
+                "CLAY"      = c( 0.450, 0.450, 0.450, 0.450, 0.250, 0.250, 0.300, 0.300, 0.300, 0.300, 0.100, 
+                                 0.100, 0.125, 0.125, 0.175, 0.175, 0.175, 0.175, 0.000, 0.000, 0.075, 0.075, 
+                                 0.075, 0.075, 0.000, 0.000, 0.000, 1.000, 0.300  ),   
+                "SILT"      = c( 0.000, 0.100, 0.350, 0.550, 0.000, 0.200, 0.250, 0.350, 0.500, 0.700, 0.000, 
+                                 0.100, 0.100, 0.325, 0.275, 0.475, 0.675, 0.825, 0.000, 0.200, 0.375, 0.575, 
+                                 0.775, 0.925, 0.450, 0.850, 1.000, 0.000, 0.550  ),   
+                "SAND"      = c( 0.550, 0.450, 0.200, 0.000, 0.750, 0.550, 0.450, 0.350, 0.200, 0.000, 0.900, 
+                                 0.800, 0.775, 0.550, 0.550, 0.350, 0.150, 0.000, 1.000, 0.800, 0.550, 0.350, 
+                                 0.150, 0.000, 0.550, 0.150, 0.000, 0.000, 0.150  )    
+            ),  #
+            # 
+            #   Abreviations;       Names of the texture cl;    Points marking the class limits (points specified above)
+            "tt.polygons"   = list( 
+                "ALO"       = list( "name" = "Argile lourde",           "points" = c(28, 01, 04                 ) ), 
+                "A"         = list( "name" = "Argile",                  "points" = c(02, 07, 09, 03             ) ), 
+                "AL"        = list( "name" = "Argile limoneuse",        "points" = c(03, 09, 10, 04             ) ), 
+                "AS"        = list( "name" = "Argile sableuse",         "points" = c(01, 05, 06, 07, 02         ) ), 
+                "LA"        = list( "name" = "Limon argileux",          "points" = c(29, 17, 18, 10             ) ), 
+                "LAS"       = list( "name" = "Limon argilo-sableux",    "points" = c(08, 16, 17, 29, 09         ) ), 
+                "LSA"       = list( "name" = "Limon sablo-argileux",    "points" = c(07, 06, 15, 16, 08         ) ), 
+                "SA"        = list( "name" = "Sable argileux",          "points" = c(05, 11, 12, 13, 14, 15, 06 ) ), 
+                "LM"        = list( "name" = "Limon moyen",             "points" = c(17, 23, 24, 18             ) ), 
+                "LMS"       = list( "name" = "Limon moyen sableux",     "points" = c(16, 22, 23, 17             ) ), 
+                "LS"        = list( "name" = "Limon sableux",           "points" = c(15, 14, 21, 22, 16         ) ), 
+                "SL"        = list( "name" = "Sable limoneux",          "points" = c(13, 12, 20, 25, 21, 14     ) ), 
[TRUNCATED]

To get the complete diff run:
    svnlook diff /svnroot/soiltexture -r 19


More information about the Soiltexture-commits mailing list