├── .Rbuildignore ├── examples ├── example_figures │ ├── README.md │ ├── cmapDori.png │ ├── cmapItto.png │ ├── cmapJean.png │ ├── cmapJin.png │ ├── cmapKlee.png │ ├── cmapMiko.png │ ├── cmapSayu.png │ ├── cmapTao.png │ ├── cmapXiao.png │ ├── cmapAlbedo.png │ ├── cmapAyaka.png │ ├── cmapBennett.png │ ├── cmapCollei.png │ ├── cmapDiona.png │ ├── cmapFaruzan.png │ ├── cmapGanyu.png │ ├── cmapKazuha.png │ ├── cmapKeqing.png │ ├── cmapKokomi.png │ ├── cmapNahida.png │ ├── cmapNilou.png │ ├── cmapNoelle.png │ ├── cmapRazor.png │ ├── cmapShenhe.png │ ├── cmapShogun.png │ ├── cmapSucrose.png │ ├── cmapVenti.png │ ├── cmapYoimiya.png │ ├── cmapZhongli.png │ ├── cmapAlhaitham.png │ ├── cmapTighnari.png │ ├── cmapXiangling.png │ └── list_of_figures.pdf └── iris.r ├── R ├── welcome.r ├── keys.r ├── Jin.r ├── Tao.r ├── Dori.r ├── Itto.r ├── Jean.r ├── Klee.r ├── Miko.r ├── Sayu.r ├── Xiao.r ├── Ayaka.r ├── Diona.r └── Ganyu.r ├── man ├── keys.Rd ├── pal_jin.Rd ├── pal_tao.Rd ├── pal_dori.Rd ├── pal_itto.Rd ├── pal_jean.Rd ├── pal_klee.Rd ├── pal_miko.Rd ├── pal_sayu.Rd ├── pal_xiao.Rd ├── pal_ayaka.Rd ├── pal_diona.Rd ├── pal_ganyu.Rd ├── pal_nilou.Rd ├── pal_razor.Rd ├── pal_venti.Rd ├── pal_albedo.Rd ├── pal_collei.Rd ├── pal_kazuha.Rd ├── pal_keqing.Rd ├── pal_kokomi.Rd ├── pal_nahida.Rd ├── pal_noelle.Rd ├── pal_shenhe.Rd ├── pal_shogun.Rd ├── pal_bennett.Rd ├── pal_faruzan.Rd ├── pal_sucrose.Rd ├── pal_yoimiya.Rd ├── pal_zhongli.Rd ├── pal_tighnari.Rd ├── pal_alhaitham.Rd ├── pal_xiangling.Rd ├── rgb_jin.Rd ├── rgb_tao.Rd ├── rgb_dori.Rd ├── rgb_itto.Rd ├── rgb_jean.Rd ├── rgb_klee.Rd ├── rgb_miko.Rd ├── rgb_sayu.Rd ├── rgb_xiao.Rd ├── rgb_ayaka.Rd ├── rgb_diona.Rd ├── rgb_ganyu.Rd ├── rgb_nilou.Rd ├── rgb_razor.Rd ├── rgb_venti.Rd ├── rgb_albedo.Rd ├── rgb_collei.Rd ├── rgb_kazuha.Rd ├── rgb_keqing.Rd ├── rgb_kokomi.Rd ├── rgb_nahida.Rd ├── rgb_noelle.Rd ├── rgb_shenhe.Rd ├── rgb_shogun.Rd ├── rgb_bennett.Rd ├── rgb_faruzan.Rd ├── rgb_sucrose.Rd ├── rgb_yoimiya.Rd ├── rgb_zhongli.Rd ├── rgb_tighnari.Rd ├── rgb_alhaitham.Rd ├── rgb_xiangling.Rd ├── scale_fill_jin.Rd ├── scale_fill_tao.Rd ├── scale_color_jin.Rd ├── scale_color_tao.Rd ├── scale_fill_dori.Rd ├── scale_fill_itto.Rd ├── scale_fill_jean.Rd ├── scale_fill_klee.Rd ├── scale_fill_miko.Rd ├── scale_fill_sayu.Rd ├── scale_fill_xiao.Rd ├── scale_color_dori.Rd ├── scale_color_itto.Rd ├── scale_color_jean.Rd ├── scale_color_klee.Rd ├── scale_color_miko.Rd ├── scale_color_sayu.Rd ├── scale_color_xiao.Rd ├── scale_fill_ayaka.Rd ├── scale_fill_diona.Rd ├── scale_fill_ganyu.Rd ├── scale_fill_nilou.Rd ├── scale_fill_razor.Rd ├── scale_fill_venti.Rd ├── scale_colour_jin.Rd ├── scale_colour_tao.Rd ├── scale_color_ayaka.Rd ├── scale_color_diona.Rd ├── scale_color_ganyu.Rd ├── scale_color_nilou.Rd ├── scale_color_razor.Rd ├── scale_color_venti.Rd ├── scale_fill_albedo.Rd ├── scale_fill_collei.Rd ├── scale_fill_kazuha.Rd ├── scale_fill_keqing.Rd ├── scale_fill_kokomi.Rd ├── scale_fill_nahida.Rd ├── scale_fill_noelle.Rd ├── scale_fill_shenhe.Rd ├── scale_fill_shogun.Rd ├── scale_colour_dori.Rd ├── scale_colour_itto.Rd ├── scale_colour_jean.Rd ├── scale_colour_klee.Rd ├── scale_colour_miko.Rd ├── scale_colour_sayu.Rd ├── scale_colour_xiao.Rd ├── scale_color_albedo.Rd ├── scale_color_collei.Rd ├── scale_color_kazuha.Rd ├── scale_color_keqing.Rd ├── scale_color_kokomi.Rd ├── scale_color_nahida.Rd ├── scale_color_noelle.Rd ├── scale_color_shenhe.Rd ├── scale_color_shogun.Rd ├── scale_fill_bennett.Rd ├── scale_fill_faruzan.Rd ├── scale_fill_sucrose.Rd ├── scale_fill_yoimiya.Rd ├── scale_fill_zhongli.Rd ├── scale_colour_ayaka.Rd ├── scale_colour_diona.Rd ├── scale_colour_ganyu.Rd ├── scale_colour_nilou.Rd ├── scale_colour_razor.Rd ├── scale_colour_venti.Rd ├── scale_color_bennett.Rd ├── scale_color_faruzan.Rd ├── scale_color_sucrose.Rd ├── scale_color_yoimiya.Rd ├── scale_color_zhongli.Rd ├── scale_fill_tighnari.Rd ├── scale_colour_albedo.Rd ├── scale_colour_collei.Rd ├── scale_colour_kazuha.Rd ├── scale_colour_keqing.Rd ├── scale_colour_kokomi.Rd ├── scale_colour_nahida.Rd ├── scale_colour_noelle.Rd ├── scale_colour_shenhe.Rd ├── scale_colour_shogun.Rd ├── scale_color_tighnari.Rd ├── scale_fill_alhaitham.Rd ├── scale_fill_xiangling.Rd ├── scale_colour_bennett.Rd ├── scale_colour_faruzan.Rd ├── scale_colour_sucrose.Rd ├── scale_colour_yoimiya.Rd ├── scale_colour_zhongli.Rd ├── scale_color_alhaitham.Rd ├── scale_color_xiangling.Rd ├── scale_colour_tighnari.Rd ├── scale_colour_alhaitham.Rd └── scale_colour_xiangling.Rd ├── ggGenshin.Rproj ├── DESCRIPTION ├── .gitignore └── README.md /.Rbuildignore: -------------------------------------------------------------------------------- 1 | ^.*\.Rproj$ 2 | ^\.Rproj\.user$ 3 | ^examples$ 4 | -------------------------------------------------------------------------------- /examples/example_figures/README.md: -------------------------------------------------------------------------------- 1 | Example figures 2 | ---- 3 | -------------------------------------------------------------------------------- /examples/example_figures/cmapDori.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapDori.png -------------------------------------------------------------------------------- /examples/example_figures/cmapItto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapItto.png -------------------------------------------------------------------------------- /examples/example_figures/cmapJean.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapJean.png -------------------------------------------------------------------------------- /examples/example_figures/cmapJin.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapJin.png -------------------------------------------------------------------------------- /examples/example_figures/cmapKlee.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapKlee.png -------------------------------------------------------------------------------- /examples/example_figures/cmapMiko.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapMiko.png -------------------------------------------------------------------------------- /examples/example_figures/cmapSayu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapSayu.png -------------------------------------------------------------------------------- /examples/example_figures/cmapTao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapTao.png -------------------------------------------------------------------------------- /examples/example_figures/cmapXiao.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapXiao.png -------------------------------------------------------------------------------- /examples/example_figures/cmapAlbedo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapAlbedo.png -------------------------------------------------------------------------------- /examples/example_figures/cmapAyaka.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapAyaka.png -------------------------------------------------------------------------------- /examples/example_figures/cmapBennett.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapBennett.png -------------------------------------------------------------------------------- /examples/example_figures/cmapCollei.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapCollei.png -------------------------------------------------------------------------------- /examples/example_figures/cmapDiona.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapDiona.png -------------------------------------------------------------------------------- /examples/example_figures/cmapFaruzan.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapFaruzan.png -------------------------------------------------------------------------------- /examples/example_figures/cmapGanyu.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapGanyu.png -------------------------------------------------------------------------------- /examples/example_figures/cmapKazuha.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapKazuha.png -------------------------------------------------------------------------------- /examples/example_figures/cmapKeqing.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapKeqing.png -------------------------------------------------------------------------------- /examples/example_figures/cmapKokomi.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapKokomi.png -------------------------------------------------------------------------------- /examples/example_figures/cmapNahida.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapNahida.png -------------------------------------------------------------------------------- /examples/example_figures/cmapNilou.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapNilou.png -------------------------------------------------------------------------------- /examples/example_figures/cmapNoelle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapNoelle.png -------------------------------------------------------------------------------- /examples/example_figures/cmapRazor.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapRazor.png -------------------------------------------------------------------------------- /examples/example_figures/cmapShenhe.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapShenhe.png -------------------------------------------------------------------------------- /examples/example_figures/cmapShogun.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapShogun.png -------------------------------------------------------------------------------- /examples/example_figures/cmapSucrose.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapSucrose.png -------------------------------------------------------------------------------- /examples/example_figures/cmapVenti.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapVenti.png -------------------------------------------------------------------------------- /examples/example_figures/cmapYoimiya.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapYoimiya.png -------------------------------------------------------------------------------- /examples/example_figures/cmapZhongli.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapZhongli.png -------------------------------------------------------------------------------- /examples/example_figures/cmapAlhaitham.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapAlhaitham.png -------------------------------------------------------------------------------- /examples/example_figures/cmapTighnari.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapTighnari.png -------------------------------------------------------------------------------- /examples/example_figures/cmapXiangling.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/cmapXiangling.png -------------------------------------------------------------------------------- /examples/example_figures/list_of_figures.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RestlessTail/ggGenshin/HEAD/examples/example_figures/list_of_figures.pdf -------------------------------------------------------------------------------- /R/welcome.r: -------------------------------------------------------------------------------- 1 | .onAttach <- function(libname, pkgname) { 2 | packageStartupMessage("This is a modification of ggsci in March 2023.\nLicensed under GPL-3.") 3 | } 4 | -------------------------------------------------------------------------------- /man/keys.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/keys.r 3 | \name{keys} 4 | \alias{keys} 5 | \title{keys} 6 | \usage{ 7 | keys() 8 | } 9 | \value{ 10 | a data frame 11 | } 12 | \description{ 13 | returns the available key names, as well as the full names in both Chinese and English 14 | } 15 | \examples{ 16 | keys() 17 | } 18 | -------------------------------------------------------------------------------- /ggGenshin.Rproj: -------------------------------------------------------------------------------- 1 | Version: 1.0 2 | 3 | RestoreWorkspace: Default 4 | SaveWorkspace: Default 5 | AlwaysSaveHistory: Default 6 | 7 | EnableCodeIndexing: Yes 8 | UseSpacesForTab: Yes 9 | NumSpacesForTab: 2 10 | Encoding: UTF-8 11 | 12 | RnwWeave: Sweave 13 | LaTeX: pdfLaTeX 14 | 15 | AutoAppendNewline: Yes 16 | StripTrailingWhitespace: Yes 17 | 18 | BuildType: Package 19 | PackageUseDevtools: Yes 20 | PackageInstallArgs: --no-multiarch --with-keep.source 21 | -------------------------------------------------------------------------------- /DESCRIPTION: -------------------------------------------------------------------------------- 1 | Package: ggGenshin 2 | Type: Package 3 | Title: ggplot palettes with Genshin style 4 | Version: 0.1.0 5 | Author: Shi Chengge 6 | Maintainer: Shi Chengge <1826930551@qq.com> 7 | Description: a package inspired by ggsci and content creator 阿昆的科研日常 of bilibili. 8 | The package provides a collection of ggplot2 color scales, whose 9 | interfaces are similar to ggsci. 10 | License: GPL-3 + file LICENSE 11 | Encoding: UTF-8 12 | LazyData: true 13 | RoxygenNote: 7.2.3 14 | Imports: ggplot2 15 | -------------------------------------------------------------------------------- /man/pal_jin.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jin.r 3 | \name{pal_jin} 4 | \alias{pal_jin} 5 | \title{pal_jin} 6 | \usage{ 7 | pal_jin(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_jin()(10) 22 | pal_jin(alpha = 0.5)(10) 23 | pal_jin(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_tao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tao.r 3 | \name{pal_tao} 4 | \alias{pal_tao} 5 | \title{pal_tao} 6 | \usage{ 7 | pal_tao(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_tao()(10) 22 | pal_tao(alpha = 0.5)(10) 23 | pal_tao(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_dori.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Dori.r 3 | \name{pal_dori} 4 | \alias{pal_dori} 5 | \title{pal_dori} 6 | \usage{ 7 | pal_dori(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_dori()(10) 22 | pal_dori(alpha = 0.5)(10) 23 | pal_dori(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_itto.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Itto.r 3 | \name{pal_itto} 4 | \alias{pal_itto} 5 | \title{pal_itto} 6 | \usage{ 7 | pal_itto(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_itto()(10) 22 | pal_itto(alpha = 0.5)(10) 23 | pal_itto(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_jean.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jean.r 3 | \name{pal_jean} 4 | \alias{pal_jean} 5 | \title{pal_jean} 6 | \usage{ 7 | pal_jean(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_jean()(10) 22 | pal_jean(alpha = 0.5)(10) 23 | pal_jean(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_klee.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Klee.r 3 | \name{pal_klee} 4 | \alias{pal_klee} 5 | \title{pal_klee} 6 | \usage{ 7 | pal_klee(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_klee()(10) 22 | pal_klee(alpha = 0.5)(10) 23 | pal_klee(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_miko.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Miko.r 3 | \name{pal_miko} 4 | \alias{pal_miko} 5 | \title{pal_miko} 6 | \usage{ 7 | pal_miko(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_miko()(10) 22 | pal_miko(alpha = 0.5)(10) 23 | pal_miko(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_sayu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sayu.r 3 | \name{pal_sayu} 4 | \alias{pal_sayu} 5 | \title{pal_sayu} 6 | \usage{ 7 | pal_sayu(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_sayu()(10) 22 | pal_sayu(alpha = 0.5)(10) 23 | pal_sayu(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_xiao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiao.r 3 | \name{pal_xiao} 4 | \alias{pal_xiao} 5 | \title{pal_xiao} 6 | \usage{ 7 | pal_xiao(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_xiao()(10) 22 | pal_xiao(alpha = 0.5)(10) 23 | pal_xiao(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_ayaka.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ayaka.r 3 | \name{pal_ayaka} 4 | \alias{pal_ayaka} 5 | \title{pal_ayaka} 6 | \usage{ 7 | pal_ayaka(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_ayaka()(10) 22 | pal_ayaka(alpha = 0.5)(10) 23 | pal_ayaka(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_diona.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Diona.r 3 | \name{pal_diona} 4 | \alias{pal_diona} 5 | \title{pal_diona} 6 | \usage{ 7 | pal_diona(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_diona()(10) 22 | pal_diona(alpha = 0.5)(10) 23 | pal_diona(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_ganyu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ganyu.r 3 | \name{pal_ganyu} 4 | \alias{pal_ganyu} 5 | \title{pal_ganyu} 6 | \usage{ 7 | pal_ganyu(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_ganyu()(10) 22 | pal_ganyu(alpha = 0.5)(10) 23 | pal_ganyu(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_nilou.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nilou.r 3 | \name{pal_nilou} 4 | \alias{pal_nilou} 5 | \title{pal_nilou} 6 | \usage{ 7 | pal_nilou(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_nilou()(10) 22 | pal_nilou(alpha = 0.5)(10) 23 | pal_nilou(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_razor.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Razor.r 3 | \name{pal_razor} 4 | \alias{pal_razor} 5 | \title{pal_razor} 6 | \usage{ 7 | pal_razor(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_razor()(10) 22 | pal_razor(alpha = 0.5)(10) 23 | pal_razor(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_venti.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Venti.r 3 | \name{pal_venti} 4 | \alias{pal_venti} 5 | \title{pal_venti} 6 | \usage{ 7 | pal_venti(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_venti()(10) 22 | pal_venti(alpha = 0.5)(10) 23 | pal_venti(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_albedo.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Albedo.r 3 | \name{pal_albedo} 4 | \alias{pal_albedo} 5 | \title{pal_albedo} 6 | \usage{ 7 | pal_albedo(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_albedo()(10) 22 | pal_albedo(alpha = 0.5)(10) 23 | pal_albedo(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_collei.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Collei.r 3 | \name{pal_collei} 4 | \alias{pal_collei} 5 | \title{pal_collei} 6 | \usage{ 7 | pal_collei(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_collei()(10) 22 | pal_collei(alpha = 0.5)(10) 23 | pal_collei(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_kazuha.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kazuha.r 3 | \name{pal_kazuha} 4 | \alias{pal_kazuha} 5 | \title{pal_kazuha} 6 | \usage{ 7 | pal_kazuha(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_kazuha()(10) 22 | pal_kazuha(alpha = 0.5)(10) 23 | pal_kazuha(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_keqing.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Keqing.r 3 | \name{pal_keqing} 4 | \alias{pal_keqing} 5 | \title{pal_keqing} 6 | \usage{ 7 | pal_keqing(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_keqing()(10) 22 | pal_keqing(alpha = 0.5)(10) 23 | pal_keqing(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_kokomi.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kokomi.r 3 | \name{pal_kokomi} 4 | \alias{pal_kokomi} 5 | \title{pal_kokomi} 6 | \usage{ 7 | pal_kokomi(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_kokomi()(10) 22 | pal_kokomi(alpha = 0.5)(10) 23 | pal_kokomi(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_nahida.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nahida.r 3 | \name{pal_nahida} 4 | \alias{pal_nahida} 5 | \title{pal_nahida} 6 | \usage{ 7 | pal_nahida(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_nahida()(10) 22 | pal_nahida(alpha = 0.5)(10) 23 | pal_nahida(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_noelle.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Noelle.r 3 | \name{pal_noelle} 4 | \alias{pal_noelle} 5 | \title{pal_noelle} 6 | \usage{ 7 | pal_noelle(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_noelle()(10) 22 | pal_noelle(alpha = 0.5)(10) 23 | pal_noelle(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_shenhe.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shenhe.r 3 | \name{pal_shenhe} 4 | \alias{pal_shenhe} 5 | \title{pal_shenhe} 6 | \usage{ 7 | pal_shenhe(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_shenhe()(10) 22 | pal_shenhe(alpha = 0.5)(10) 23 | pal_shenhe(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_shogun.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shogun.r 3 | \name{pal_shogun} 4 | \alias{pal_shogun} 5 | \title{pal_shogun} 6 | \usage{ 7 | pal_shogun(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_shogun()(10) 22 | pal_shogun(alpha = 0.5)(10) 23 | pal_shogun(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_bennett.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Bennett.r 3 | \name{pal_bennett} 4 | \alias{pal_bennett} 5 | \title{pal_bennett} 6 | \usage{ 7 | pal_bennett(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_bennett()(10) 22 | pal_bennett(alpha = 0.5)(10) 23 | pal_bennett(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_faruzan.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Faruzan.r 3 | \name{pal_faruzan} 4 | \alias{pal_faruzan} 5 | \title{pal_faruzan} 6 | \usage{ 7 | pal_faruzan(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_faruzan()(10) 22 | pal_faruzan(alpha = 0.5)(10) 23 | pal_faruzan(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_sucrose.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sucrose.r 3 | \name{pal_sucrose} 4 | \alias{pal_sucrose} 5 | \title{pal_sucrose} 6 | \usage{ 7 | pal_sucrose(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_sucrose()(10) 22 | pal_sucrose(alpha = 0.5)(10) 23 | pal_sucrose(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_yoimiya.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Yoimiya.r 3 | \name{pal_yoimiya} 4 | \alias{pal_yoimiya} 5 | \title{pal_yoimiya} 6 | \usage{ 7 | pal_yoimiya(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_yoimiya()(10) 22 | pal_yoimiya(alpha = 0.5)(10) 23 | pal_yoimiya(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_zhongli.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Zhongli.r 3 | \name{pal_zhongli} 4 | \alias{pal_zhongli} 5 | \title{pal_zhongli} 6 | \usage{ 7 | pal_zhongli(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_zhongli()(10) 22 | pal_zhongli(alpha = 0.5)(10) 23 | pal_zhongli(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_tighnari.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tighnari.r 3 | \name{pal_tighnari} 4 | \alias{pal_tighnari} 5 | \title{pal_tighnari} 6 | \usage{ 7 | pal_tighnari(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_tighnari()(10) 22 | pal_tighnari(alpha = 0.5)(10) 23 | pal_tighnari(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_alhaitham.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Alhaitham.r 3 | \name{pal_alhaitham} 4 | \alias{pal_alhaitham} 5 | \title{pal_alhaitham} 6 | \usage{ 7 | pal_alhaitham(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_alhaitham()(10) 22 | pal_alhaitham(alpha = 0.5)(10) 23 | pal_alhaitham(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/pal_xiangling.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiangling.r 3 | \name{pal_xiangling} 4 | \alias{pal_xiangling} 5 | \title{pal_xiangling} 6 | \usage{ 7 | pal_xiangling(alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{alpha}{the alpha value of each color} 11 | 12 | \item{reverse}{invert the color sequence} 13 | } 14 | \value{ 15 | a vector of hexadecimal colors 16 | } 17 | \description{ 18 | Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 19 | } 20 | \examples{ 21 | pal_xiangling()(10) 22 | pal_xiangling(alpha = 0.5)(10) 23 | pal_xiangling(alpha = 0.5, reverse = TRUE)(20) 24 | } 25 | -------------------------------------------------------------------------------- /man/rgb_jin.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jin.r 3 | \name{rgb_jin} 4 | \alias{rgb_jin} 5 | \title{rgb_jin} 6 | \usage{ 7 | rgb_jin(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_jin() 24 | rgb_jin(10) 25 | rgb_jin(n = 10, alpha = 0.5) 26 | rgb_jin(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_tao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tao.r 3 | \name{rgb_tao} 4 | \alias{rgb_tao} 5 | \title{rgb_tao} 6 | \usage{ 7 | rgb_tao(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_tao() 24 | rgb_tao(10) 25 | rgb_tao(n = 10, alpha = 0.5) 26 | rgb_tao(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_dori.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Dori.r 3 | \name{rgb_dori} 4 | \alias{rgb_dori} 5 | \title{rgb_dori} 6 | \usage{ 7 | rgb_dori(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_dori() 24 | rgb_dori(10) 25 | rgb_dori(n = 10, alpha = 0.5) 26 | rgb_dori(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_itto.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Itto.r 3 | \name{rgb_itto} 4 | \alias{rgb_itto} 5 | \title{rgb_itto} 6 | \usage{ 7 | rgb_itto(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_itto() 24 | rgb_itto(10) 25 | rgb_itto(n = 10, alpha = 0.5) 26 | rgb_itto(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_jean.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jean.r 3 | \name{rgb_jean} 4 | \alias{rgb_jean} 5 | \title{rgb_jean} 6 | \usage{ 7 | rgb_jean(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_jean() 24 | rgb_jean(10) 25 | rgb_jean(n = 10, alpha = 0.5) 26 | rgb_jean(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_klee.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Klee.r 3 | \name{rgb_klee} 4 | \alias{rgb_klee} 5 | \title{rgb_klee} 6 | \usage{ 7 | rgb_klee(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_klee() 24 | rgb_klee(10) 25 | rgb_klee(n = 10, alpha = 0.5) 26 | rgb_klee(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_miko.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Miko.r 3 | \name{rgb_miko} 4 | \alias{rgb_miko} 5 | \title{rgb_miko} 6 | \usage{ 7 | rgb_miko(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_miko() 24 | rgb_miko(10) 25 | rgb_miko(n = 10, alpha = 0.5) 26 | rgb_miko(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_sayu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sayu.r 3 | \name{rgb_sayu} 4 | \alias{rgb_sayu} 5 | \title{rgb_sayu} 6 | \usage{ 7 | rgb_sayu(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_sayu() 24 | rgb_sayu(10) 25 | rgb_sayu(n = 10, alpha = 0.5) 26 | rgb_sayu(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_xiao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiao.r 3 | \name{rgb_xiao} 4 | \alias{rgb_xiao} 5 | \title{rgb_xiao} 6 | \usage{ 7 | rgb_xiao(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_xiao() 24 | rgb_xiao(10) 25 | rgb_xiao(n = 10, alpha = 0.5) 26 | rgb_xiao(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_ayaka.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ayaka.r 3 | \name{rgb_ayaka} 4 | \alias{rgb_ayaka} 5 | \title{rgb_ayaka} 6 | \usage{ 7 | rgb_ayaka(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_ayaka() 24 | rgb_ayaka(10) 25 | rgb_ayaka(n = 10, alpha = 0.5) 26 | rgb_ayaka(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_diona.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Diona.r 3 | \name{rgb_diona} 4 | \alias{rgb_diona} 5 | \title{rgb_diona} 6 | \usage{ 7 | rgb_diona(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_diona() 24 | rgb_diona(10) 25 | rgb_diona(n = 10, alpha = 0.5) 26 | rgb_diona(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_ganyu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ganyu.r 3 | \name{rgb_ganyu} 4 | \alias{rgb_ganyu} 5 | \title{rgb_ganyu} 6 | \usage{ 7 | rgb_ganyu(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_ganyu() 24 | rgb_ganyu(10) 25 | rgb_ganyu(n = 10, alpha = 0.5) 26 | rgb_ganyu(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_nilou.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nilou.r 3 | \name{rgb_nilou} 4 | \alias{rgb_nilou} 5 | \title{rgb_nilou} 6 | \usage{ 7 | rgb_nilou(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_nilou() 24 | rgb_nilou(10) 25 | rgb_nilou(n = 10, alpha = 0.5) 26 | rgb_nilou(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_razor.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Razor.r 3 | \name{rgb_razor} 4 | \alias{rgb_razor} 5 | \title{rgb_razor} 6 | \usage{ 7 | rgb_razor(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_razor() 24 | rgb_razor(10) 25 | rgb_razor(n = 10, alpha = 0.5) 26 | rgb_razor(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_venti.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Venti.r 3 | \name{rgb_venti} 4 | \alias{rgb_venti} 5 | \title{rgb_venti} 6 | \usage{ 7 | rgb_venti(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_venti() 24 | rgb_venti(10) 25 | rgb_venti(n = 10, alpha = 0.5) 26 | rgb_venti(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_albedo.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Albedo.r 3 | \name{rgb_albedo} 4 | \alias{rgb_albedo} 5 | \title{rgb_albedo} 6 | \usage{ 7 | rgb_albedo(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_albedo() 24 | rgb_albedo(10) 25 | rgb_albedo(n = 10, alpha = 0.5) 26 | rgb_albedo(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_collei.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Collei.r 3 | \name{rgb_collei} 4 | \alias{rgb_collei} 5 | \title{rgb_collei} 6 | \usage{ 7 | rgb_collei(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_collei() 24 | rgb_collei(10) 25 | rgb_collei(n = 10, alpha = 0.5) 26 | rgb_collei(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_kazuha.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kazuha.r 3 | \name{rgb_kazuha} 4 | \alias{rgb_kazuha} 5 | \title{rgb_kazuha} 6 | \usage{ 7 | rgb_kazuha(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_kazuha() 24 | rgb_kazuha(10) 25 | rgb_kazuha(n = 10, alpha = 0.5) 26 | rgb_kazuha(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_keqing.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Keqing.r 3 | \name{rgb_keqing} 4 | \alias{rgb_keqing} 5 | \title{rgb_keqing} 6 | \usage{ 7 | rgb_keqing(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_keqing() 24 | rgb_keqing(10) 25 | rgb_keqing(n = 10, alpha = 0.5) 26 | rgb_keqing(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_kokomi.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kokomi.r 3 | \name{rgb_kokomi} 4 | \alias{rgb_kokomi} 5 | \title{rgb_kokomi} 6 | \usage{ 7 | rgb_kokomi(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_kokomi() 24 | rgb_kokomi(10) 25 | rgb_kokomi(n = 10, alpha = 0.5) 26 | rgb_kokomi(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_nahida.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nahida.r 3 | \name{rgb_nahida} 4 | \alias{rgb_nahida} 5 | \title{rgb_nahida} 6 | \usage{ 7 | rgb_nahida(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_nahida() 24 | rgb_nahida(10) 25 | rgb_nahida(n = 10, alpha = 0.5) 26 | rgb_nahida(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_noelle.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Noelle.r 3 | \name{rgb_noelle} 4 | \alias{rgb_noelle} 5 | \title{rgb_noelle} 6 | \usage{ 7 | rgb_noelle(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_noelle() 24 | rgb_noelle(10) 25 | rgb_noelle(n = 10, alpha = 0.5) 26 | rgb_noelle(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_shenhe.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shenhe.r 3 | \name{rgb_shenhe} 4 | \alias{rgb_shenhe} 5 | \title{rgb_shenhe} 6 | \usage{ 7 | rgb_shenhe(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_shenhe() 24 | rgb_shenhe(10) 25 | rgb_shenhe(n = 10, alpha = 0.5) 26 | rgb_shenhe(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_shogun.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shogun.r 3 | \name{rgb_shogun} 4 | \alias{rgb_shogun} 5 | \title{rgb_shogun} 6 | \usage{ 7 | rgb_shogun(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_shogun() 24 | rgb_shogun(10) 25 | rgb_shogun(n = 10, alpha = 0.5) 26 | rgb_shogun(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /examples/iris.r: -------------------------------------------------------------------------------- 1 | library("ggGenshin") 2 | library("ggplot2") 3 | library("reshape2") 4 | library("dplyr") 5 | 6 | dat1 = aggregate(iris[, 1:4], by = list(iris$Species), mean) %>% 7 | melt() %>% 8 | rename(species = Group.1) 9 | p1 = ggplot(dat1) + 10 | geom_col(aes(x = variable, y = value, fill = species), position = "dodge") + 11 | theme_test() 12 | 13 | dat2 = iris[, c(5, 1, 2, 3)] 14 | p2 = ggplot(dat2) + 15 | geom_point(aes(x = Sepal.Length, y = Sepal.Width, color = Petal.Length), size = 3) + 16 | theme_test() 17 | 18 | if(dir.exists("out") == FALSE){ 19 | dir.create("out") 20 | } 21 | 22 | ggsave("out/albedo.png", p1 + scale_fill_albedo(), width = 6, height = 3) 23 | ggsave("out/yoimiya.png", p2 + scale_color_yoimiya(F), width = 6, height = 3) 24 | -------------------------------------------------------------------------------- /man/rgb_bennett.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Bennett.r 3 | \name{rgb_bennett} 4 | \alias{rgb_bennett} 5 | \title{rgb_bennett} 6 | \usage{ 7 | rgb_bennett(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_bennett() 24 | rgb_bennett(10) 25 | rgb_bennett(n = 10, alpha = 0.5) 26 | rgb_bennett(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_faruzan.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Faruzan.r 3 | \name{rgb_faruzan} 4 | \alias{rgb_faruzan} 5 | \title{rgb_faruzan} 6 | \usage{ 7 | rgb_faruzan(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_faruzan() 24 | rgb_faruzan(10) 25 | rgb_faruzan(n = 10, alpha = 0.5) 26 | rgb_faruzan(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_sucrose.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sucrose.r 3 | \name{rgb_sucrose} 4 | \alias{rgb_sucrose} 5 | \title{rgb_sucrose} 6 | \usage{ 7 | rgb_sucrose(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_sucrose() 24 | rgb_sucrose(10) 25 | rgb_sucrose(n = 10, alpha = 0.5) 26 | rgb_sucrose(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_yoimiya.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Yoimiya.r 3 | \name{rgb_yoimiya} 4 | \alias{rgb_yoimiya} 5 | \title{rgb_yoimiya} 6 | \usage{ 7 | rgb_yoimiya(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_yoimiya() 24 | rgb_yoimiya(10) 25 | rgb_yoimiya(n = 10, alpha = 0.5) 26 | rgb_yoimiya(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_zhongli.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Zhongli.r 3 | \name{rgb_zhongli} 4 | \alias{rgb_zhongli} 5 | \title{rgb_zhongli} 6 | \usage{ 7 | rgb_zhongli(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_zhongli() 24 | rgb_zhongli(10) 25 | rgb_zhongli(n = 10, alpha = 0.5) 26 | rgb_zhongli(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_tighnari.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tighnari.r 3 | \name{rgb_tighnari} 4 | \alias{rgb_tighnari} 5 | \title{rgb_tighnari} 6 | \usage{ 7 | rgb_tighnari(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_tighnari() 24 | rgb_tighnari(10) 25 | rgb_tighnari(n = 10, alpha = 0.5) 26 | rgb_tighnari(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_alhaitham.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Alhaitham.r 3 | \name{rgb_alhaitham} 4 | \alias{rgb_alhaitham} 5 | \title{rgb_alhaitham} 6 | \usage{ 7 | rgb_alhaitham(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_alhaitham() 24 | rgb_alhaitham(10) 25 | rgb_alhaitham(n = 10, alpha = 0.5) 26 | rgb_alhaitham(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /man/rgb_xiangling.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiangling.r 3 | \name{rgb_xiangling} 4 | \alias{rgb_xiangling} 5 | \title{rgb_xiangling} 6 | \usage{ 7 | rgb_xiangling(n = 12, alpha = 1, reverse = FALSE) 8 | } 9 | \arguments{ 10 | \item{n}{the number of colors generated} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | } 16 | \value{ 17 | a vector of hexadecimal colors 18 | } 19 | \description{ 20 | Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 21 | } 22 | \examples{ 23 | rgb_xiangling() 24 | rgb_xiangling(10) 25 | rgb_xiangling(n = 10, alpha = 0.5) 26 | rgb_xiangling(n = 20, alpha = 0.7, reverse = TRUE) 27 | } 28 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # History files 2 | .Rhistory 3 | .Rapp.history 4 | 5 | # Session Data files 6 | .RData 7 | 8 | # User-specific files 9 | .Ruserdata 10 | 11 | # Example code in package build process 12 | *-Ex.R 13 | 14 | # Output files from R CMD build 15 | /*.tar.gz 16 | 17 | # Output files from R CMD check 18 | /*.Rcheck/ 19 | 20 | # RStudio files 21 | .Rproj.user/ 22 | 23 | # produced vignettes 24 | vignettes/*.html 25 | vignettes/*.pdf 26 | 27 | # OAuth2 token, see https://github.com/hadley/httr/releases/tag/v0.3 28 | .httr-oauth 29 | 30 | # knitr and R markdown default cache directories 31 | *_cache/ 32 | /cache/ 33 | 34 | # Temporary files created by R markdown 35 | *.utf8.md 36 | *.knit.md 37 | 38 | # R Environment Variables 39 | .Renviron 40 | 41 | # Python setuptools directories 42 | __pycache__/ 43 | build/ 44 | dist/ 45 | ggGenshinPy.egg-info/ 46 | -------------------------------------------------------------------------------- /man/scale_fill_jin.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jin.r 3 | \name{scale_fill_jin} 4 | \alias{scale_fill_jin} 5 | \title{scale_fill_jin} 6 | \usage{ 7 | scale_fill_jin(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_jin() 26 | scale_fill_jin(FALSE) 27 | scale_fill_jin(alpha = 0.5) 28 | scale_fill_jin(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_tao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tao.r 3 | \name{scale_fill_tao} 4 | \alias{scale_fill_tao} 5 | \title{scale_fill_tao} 6 | \usage{ 7 | scale_fill_tao(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_tao() 26 | scale_fill_tao(FALSE) 27 | scale_fill_tao(alpha = 0.5) 28 | scale_fill_tao(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_jin.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jin.r 3 | \name{scale_color_jin} 4 | \alias{scale_color_jin} 5 | \title{scale_color_jin} 6 | \usage{ 7 | scale_color_jin(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_jin() 26 | scale_color_jin(FALSE) 27 | scale_color_jin(alpha = 0.5) 28 | scale_color_jin(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_tao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tao.r 3 | \name{scale_color_tao} 4 | \alias{scale_color_tao} 5 | \title{scale_color_tao} 6 | \usage{ 7 | scale_color_tao(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_tao() 26 | scale_color_tao(FALSE) 27 | scale_color_tao(alpha = 0.5) 28 | scale_color_tao(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_dori.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Dori.r 3 | \name{scale_fill_dori} 4 | \alias{scale_fill_dori} 5 | \title{scale_fill_dori} 6 | \usage{ 7 | scale_fill_dori(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_dori() 26 | scale_fill_dori(FALSE) 27 | scale_fill_dori(alpha = 0.5) 28 | scale_fill_dori(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_itto.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Itto.r 3 | \name{scale_fill_itto} 4 | \alias{scale_fill_itto} 5 | \title{scale_fill_itto} 6 | \usage{ 7 | scale_fill_itto(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_itto() 26 | scale_fill_itto(FALSE) 27 | scale_fill_itto(alpha = 0.5) 28 | scale_fill_itto(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_jean.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jean.r 3 | \name{scale_fill_jean} 4 | \alias{scale_fill_jean} 5 | \title{scale_fill_jean} 6 | \usage{ 7 | scale_fill_jean(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_jean() 26 | scale_fill_jean(FALSE) 27 | scale_fill_jean(alpha = 0.5) 28 | scale_fill_jean(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_klee.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Klee.r 3 | \name{scale_fill_klee} 4 | \alias{scale_fill_klee} 5 | \title{scale_fill_klee} 6 | \usage{ 7 | scale_fill_klee(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_klee() 26 | scale_fill_klee(FALSE) 27 | scale_fill_klee(alpha = 0.5) 28 | scale_fill_klee(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_miko.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Miko.r 3 | \name{scale_fill_miko} 4 | \alias{scale_fill_miko} 5 | \title{scale_fill_miko} 6 | \usage{ 7 | scale_fill_miko(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_miko() 26 | scale_fill_miko(FALSE) 27 | scale_fill_miko(alpha = 0.5) 28 | scale_fill_miko(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_sayu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sayu.r 3 | \name{scale_fill_sayu} 4 | \alias{scale_fill_sayu} 5 | \title{scale_fill_sayu} 6 | \usage{ 7 | scale_fill_sayu(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_sayu() 26 | scale_fill_sayu(FALSE) 27 | scale_fill_sayu(alpha = 0.5) 28 | scale_fill_sayu(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_xiao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiao.r 3 | \name{scale_fill_xiao} 4 | \alias{scale_fill_xiao} 5 | \title{scale_fill_xiao} 6 | \usage{ 7 | scale_fill_xiao(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_xiao() 26 | scale_fill_xiao(FALSE) 27 | scale_fill_xiao(alpha = 0.5) 28 | scale_fill_xiao(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_dori.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Dori.r 3 | \name{scale_color_dori} 4 | \alias{scale_color_dori} 5 | \title{scale_color_dori} 6 | \usage{ 7 | scale_color_dori(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_dori() 26 | scale_color_dori(FALSE) 27 | scale_color_dori(alpha = 0.5) 28 | scale_color_dori(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_itto.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Itto.r 3 | \name{scale_color_itto} 4 | \alias{scale_color_itto} 5 | \title{scale_color_itto} 6 | \usage{ 7 | scale_color_itto(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_itto() 26 | scale_color_itto(FALSE) 27 | scale_color_itto(alpha = 0.5) 28 | scale_color_itto(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_jean.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jean.r 3 | \name{scale_color_jean} 4 | \alias{scale_color_jean} 5 | \title{scale_color_jean} 6 | \usage{ 7 | scale_color_jean(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_jean() 26 | scale_color_jean(FALSE) 27 | scale_color_jean(alpha = 0.5) 28 | scale_color_jean(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_klee.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Klee.r 3 | \name{scale_color_klee} 4 | \alias{scale_color_klee} 5 | \title{scale_color_klee} 6 | \usage{ 7 | scale_color_klee(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_klee() 26 | scale_color_klee(FALSE) 27 | scale_color_klee(alpha = 0.5) 28 | scale_color_klee(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_miko.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Miko.r 3 | \name{scale_color_miko} 4 | \alias{scale_color_miko} 5 | \title{scale_color_miko} 6 | \usage{ 7 | scale_color_miko(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_miko() 26 | scale_color_miko(FALSE) 27 | scale_color_miko(alpha = 0.5) 28 | scale_color_miko(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_sayu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sayu.r 3 | \name{scale_color_sayu} 4 | \alias{scale_color_sayu} 5 | \title{scale_color_sayu} 6 | \usage{ 7 | scale_color_sayu(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_sayu() 26 | scale_color_sayu(FALSE) 27 | scale_color_sayu(alpha = 0.5) 28 | scale_color_sayu(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_xiao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiao.r 3 | \name{scale_color_xiao} 4 | \alias{scale_color_xiao} 5 | \title{scale_color_xiao} 6 | \usage{ 7 | scale_color_xiao(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_xiao() 26 | scale_color_xiao(FALSE) 27 | scale_color_xiao(alpha = 0.5) 28 | scale_color_xiao(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_ayaka.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ayaka.r 3 | \name{scale_fill_ayaka} 4 | \alias{scale_fill_ayaka} 5 | \title{scale_fill_ayaka} 6 | \usage{ 7 | scale_fill_ayaka(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_ayaka() 26 | scale_fill_ayaka(FALSE) 27 | scale_fill_ayaka(alpha = 0.5) 28 | scale_fill_ayaka(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_diona.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Diona.r 3 | \name{scale_fill_diona} 4 | \alias{scale_fill_diona} 5 | \title{scale_fill_diona} 6 | \usage{ 7 | scale_fill_diona(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_diona() 26 | scale_fill_diona(FALSE) 27 | scale_fill_diona(alpha = 0.5) 28 | scale_fill_diona(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_ganyu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ganyu.r 3 | \name{scale_fill_ganyu} 4 | \alias{scale_fill_ganyu} 5 | \title{scale_fill_ganyu} 6 | \usage{ 7 | scale_fill_ganyu(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_ganyu() 26 | scale_fill_ganyu(FALSE) 27 | scale_fill_ganyu(alpha = 0.5) 28 | scale_fill_ganyu(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_nilou.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nilou.r 3 | \name{scale_fill_nilou} 4 | \alias{scale_fill_nilou} 5 | \title{scale_fill_nilou} 6 | \usage{ 7 | scale_fill_nilou(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_nilou() 26 | scale_fill_nilou(FALSE) 27 | scale_fill_nilou(alpha = 0.5) 28 | scale_fill_nilou(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_razor.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Razor.r 3 | \name{scale_fill_razor} 4 | \alias{scale_fill_razor} 5 | \title{scale_fill_razor} 6 | \usage{ 7 | scale_fill_razor(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_razor() 26 | scale_fill_razor(FALSE) 27 | scale_fill_razor(alpha = 0.5) 28 | scale_fill_razor(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_venti.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Venti.r 3 | \name{scale_fill_venti} 4 | \alias{scale_fill_venti} 5 | \title{scale_fill_venti} 6 | \usage{ 7 | scale_fill_venti(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_venti() 26 | scale_fill_venti(FALSE) 27 | scale_fill_venti(alpha = 0.5) 28 | scale_fill_venti(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_jin.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jin.r 3 | \name{scale_colour_jin} 4 | \alias{scale_colour_jin} 5 | \title{scale_colour_jin} 6 | \usage{ 7 | scale_colour_jin(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_jin() 26 | scale_colour_jin(FALSE) 27 | scale_colour_jin(alpha = 0.5) 28 | scale_colour_jin(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_tao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tao.r 3 | \name{scale_colour_tao} 4 | \alias{scale_colour_tao} 5 | \title{scale_colour_tao} 6 | \usage{ 7 | scale_colour_tao(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_tao() 26 | scale_colour_tao(FALSE) 27 | scale_colour_tao(alpha = 0.5) 28 | scale_colour_tao(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_ayaka.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ayaka.r 3 | \name{scale_color_ayaka} 4 | \alias{scale_color_ayaka} 5 | \title{scale_color_ayaka} 6 | \usage{ 7 | scale_color_ayaka(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_ayaka() 26 | scale_color_ayaka(FALSE) 27 | scale_color_ayaka(alpha = 0.5) 28 | scale_color_ayaka(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_diona.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Diona.r 3 | \name{scale_color_diona} 4 | \alias{scale_color_diona} 5 | \title{scale_color_diona} 6 | \usage{ 7 | scale_color_diona(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_diona() 26 | scale_color_diona(FALSE) 27 | scale_color_diona(alpha = 0.5) 28 | scale_color_diona(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_ganyu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ganyu.r 3 | \name{scale_color_ganyu} 4 | \alias{scale_color_ganyu} 5 | \title{scale_color_ganyu} 6 | \usage{ 7 | scale_color_ganyu(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_ganyu() 26 | scale_color_ganyu(FALSE) 27 | scale_color_ganyu(alpha = 0.5) 28 | scale_color_ganyu(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_nilou.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nilou.r 3 | \name{scale_color_nilou} 4 | \alias{scale_color_nilou} 5 | \title{scale_color_nilou} 6 | \usage{ 7 | scale_color_nilou(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_nilou() 26 | scale_color_nilou(FALSE) 27 | scale_color_nilou(alpha = 0.5) 28 | scale_color_nilou(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_razor.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Razor.r 3 | \name{scale_color_razor} 4 | \alias{scale_color_razor} 5 | \title{scale_color_razor} 6 | \usage{ 7 | scale_color_razor(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_razor() 26 | scale_color_razor(FALSE) 27 | scale_color_razor(alpha = 0.5) 28 | scale_color_razor(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_venti.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Venti.r 3 | \name{scale_color_venti} 4 | \alias{scale_color_venti} 5 | \title{scale_color_venti} 6 | \usage{ 7 | scale_color_venti(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_venti() 26 | scale_color_venti(FALSE) 27 | scale_color_venti(alpha = 0.5) 28 | scale_color_venti(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_albedo.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Albedo.r 3 | \name{scale_fill_albedo} 4 | \alias{scale_fill_albedo} 5 | \title{scale_fill_albedo} 6 | \usage{ 7 | scale_fill_albedo(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_albedo() 26 | scale_fill_albedo(FALSE) 27 | scale_fill_albedo(alpha = 0.5) 28 | scale_fill_albedo(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_collei.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Collei.r 3 | \name{scale_fill_collei} 4 | \alias{scale_fill_collei} 5 | \title{scale_fill_collei} 6 | \usage{ 7 | scale_fill_collei(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_collei() 26 | scale_fill_collei(FALSE) 27 | scale_fill_collei(alpha = 0.5) 28 | scale_fill_collei(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_kazuha.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kazuha.r 3 | \name{scale_fill_kazuha} 4 | \alias{scale_fill_kazuha} 5 | \title{scale_fill_kazuha} 6 | \usage{ 7 | scale_fill_kazuha(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_kazuha() 26 | scale_fill_kazuha(FALSE) 27 | scale_fill_kazuha(alpha = 0.5) 28 | scale_fill_kazuha(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_keqing.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Keqing.r 3 | \name{scale_fill_keqing} 4 | \alias{scale_fill_keqing} 5 | \title{scale_fill_keqing} 6 | \usage{ 7 | scale_fill_keqing(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_keqing() 26 | scale_fill_keqing(FALSE) 27 | scale_fill_keqing(alpha = 0.5) 28 | scale_fill_keqing(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_kokomi.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kokomi.r 3 | \name{scale_fill_kokomi} 4 | \alias{scale_fill_kokomi} 5 | \title{scale_fill_kokomi} 6 | \usage{ 7 | scale_fill_kokomi(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_kokomi() 26 | scale_fill_kokomi(FALSE) 27 | scale_fill_kokomi(alpha = 0.5) 28 | scale_fill_kokomi(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_nahida.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nahida.r 3 | \name{scale_fill_nahida} 4 | \alias{scale_fill_nahida} 5 | \title{scale_fill_nahida} 6 | \usage{ 7 | scale_fill_nahida(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_nahida() 26 | scale_fill_nahida(FALSE) 27 | scale_fill_nahida(alpha = 0.5) 28 | scale_fill_nahida(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_noelle.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Noelle.r 3 | \name{scale_fill_noelle} 4 | \alias{scale_fill_noelle} 5 | \title{scale_fill_noelle} 6 | \usage{ 7 | scale_fill_noelle(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_noelle() 26 | scale_fill_noelle(FALSE) 27 | scale_fill_noelle(alpha = 0.5) 28 | scale_fill_noelle(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_shenhe.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shenhe.r 3 | \name{scale_fill_shenhe} 4 | \alias{scale_fill_shenhe} 5 | \title{scale_fill_shenhe} 6 | \usage{ 7 | scale_fill_shenhe(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_shenhe() 26 | scale_fill_shenhe(FALSE) 27 | scale_fill_shenhe(alpha = 0.5) 28 | scale_fill_shenhe(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_shogun.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shogun.r 3 | \name{scale_fill_shogun} 4 | \alias{scale_fill_shogun} 5 | \title{scale_fill_shogun} 6 | \usage{ 7 | scale_fill_shogun(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_shogun() 26 | scale_fill_shogun(FALSE) 27 | scale_fill_shogun(alpha = 0.5) 28 | scale_fill_shogun(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_dori.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Dori.r 3 | \name{scale_colour_dori} 4 | \alias{scale_colour_dori} 5 | \title{scale_colour_dori} 6 | \usage{ 7 | scale_colour_dori(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_dori() 26 | scale_colour_dori(FALSE) 27 | scale_colour_dori(alpha = 0.5) 28 | scale_colour_dori(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_itto.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Itto.r 3 | \name{scale_colour_itto} 4 | \alias{scale_colour_itto} 5 | \title{scale_colour_itto} 6 | \usage{ 7 | scale_colour_itto(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_itto() 26 | scale_colour_itto(FALSE) 27 | scale_colour_itto(alpha = 0.5) 28 | scale_colour_itto(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_jean.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Jean.r 3 | \name{scale_colour_jean} 4 | \alias{scale_colour_jean} 5 | \title{scale_colour_jean} 6 | \usage{ 7 | scale_colour_jean(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_jean() 26 | scale_colour_jean(FALSE) 27 | scale_colour_jean(alpha = 0.5) 28 | scale_colour_jean(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_klee.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Klee.r 3 | \name{scale_colour_klee} 4 | \alias{scale_colour_klee} 5 | \title{scale_colour_klee} 6 | \usage{ 7 | scale_colour_klee(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_klee() 26 | scale_colour_klee(FALSE) 27 | scale_colour_klee(alpha = 0.5) 28 | scale_colour_klee(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_miko.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Miko.r 3 | \name{scale_colour_miko} 4 | \alias{scale_colour_miko} 5 | \title{scale_colour_miko} 6 | \usage{ 7 | scale_colour_miko(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_miko() 26 | scale_colour_miko(FALSE) 27 | scale_colour_miko(alpha = 0.5) 28 | scale_colour_miko(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_sayu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sayu.r 3 | \name{scale_colour_sayu} 4 | \alias{scale_colour_sayu} 5 | \title{scale_colour_sayu} 6 | \usage{ 7 | scale_colour_sayu(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_sayu() 26 | scale_colour_sayu(FALSE) 27 | scale_colour_sayu(alpha = 0.5) 28 | scale_colour_sayu(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_xiao.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiao.r 3 | \name{scale_colour_xiao} 4 | \alias{scale_colour_xiao} 5 | \title{scale_colour_xiao} 6 | \usage{ 7 | scale_colour_xiao(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_xiao() 26 | scale_colour_xiao(FALSE) 27 | scale_colour_xiao(alpha = 0.5) 28 | scale_colour_xiao(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_albedo.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Albedo.r 3 | \name{scale_color_albedo} 4 | \alias{scale_color_albedo} 5 | \title{scale_color_albedo} 6 | \usage{ 7 | scale_color_albedo(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_albedo() 26 | scale_color_albedo(FALSE) 27 | scale_color_albedo(alpha = 0.5) 28 | scale_color_albedo(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_collei.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Collei.r 3 | \name{scale_color_collei} 4 | \alias{scale_color_collei} 5 | \title{scale_color_collei} 6 | \usage{ 7 | scale_color_collei(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_collei() 26 | scale_color_collei(FALSE) 27 | scale_color_collei(alpha = 0.5) 28 | scale_color_collei(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_kazuha.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kazuha.r 3 | \name{scale_color_kazuha} 4 | \alias{scale_color_kazuha} 5 | \title{scale_color_kazuha} 6 | \usage{ 7 | scale_color_kazuha(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_kazuha() 26 | scale_color_kazuha(FALSE) 27 | scale_color_kazuha(alpha = 0.5) 28 | scale_color_kazuha(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_keqing.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Keqing.r 3 | \name{scale_color_keqing} 4 | \alias{scale_color_keqing} 5 | \title{scale_color_keqing} 6 | \usage{ 7 | scale_color_keqing(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_keqing() 26 | scale_color_keqing(FALSE) 27 | scale_color_keqing(alpha = 0.5) 28 | scale_color_keqing(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_kokomi.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kokomi.r 3 | \name{scale_color_kokomi} 4 | \alias{scale_color_kokomi} 5 | \title{scale_color_kokomi} 6 | \usage{ 7 | scale_color_kokomi(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_kokomi() 26 | scale_color_kokomi(FALSE) 27 | scale_color_kokomi(alpha = 0.5) 28 | scale_color_kokomi(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_nahida.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nahida.r 3 | \name{scale_color_nahida} 4 | \alias{scale_color_nahida} 5 | \title{scale_color_nahida} 6 | \usage{ 7 | scale_color_nahida(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_nahida() 26 | scale_color_nahida(FALSE) 27 | scale_color_nahida(alpha = 0.5) 28 | scale_color_nahida(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_noelle.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Noelle.r 3 | \name{scale_color_noelle} 4 | \alias{scale_color_noelle} 5 | \title{scale_color_noelle} 6 | \usage{ 7 | scale_color_noelle(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_noelle() 26 | scale_color_noelle(FALSE) 27 | scale_color_noelle(alpha = 0.5) 28 | scale_color_noelle(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_shenhe.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shenhe.r 3 | \name{scale_color_shenhe} 4 | \alias{scale_color_shenhe} 5 | \title{scale_color_shenhe} 6 | \usage{ 7 | scale_color_shenhe(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_shenhe() 26 | scale_color_shenhe(FALSE) 27 | scale_color_shenhe(alpha = 0.5) 28 | scale_color_shenhe(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_shogun.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shogun.r 3 | \name{scale_color_shogun} 4 | \alias{scale_color_shogun} 5 | \title{scale_color_shogun} 6 | \usage{ 7 | scale_color_shogun(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_shogun() 26 | scale_color_shogun(FALSE) 27 | scale_color_shogun(alpha = 0.5) 28 | scale_color_shogun(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_bennett.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Bennett.r 3 | \name{scale_fill_bennett} 4 | \alias{scale_fill_bennett} 5 | \title{scale_fill_bennett} 6 | \usage{ 7 | scale_fill_bennett(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_bennett() 26 | scale_fill_bennett(FALSE) 27 | scale_fill_bennett(alpha = 0.5) 28 | scale_fill_bennett(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_faruzan.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Faruzan.r 3 | \name{scale_fill_faruzan} 4 | \alias{scale_fill_faruzan} 5 | \title{scale_fill_faruzan} 6 | \usage{ 7 | scale_fill_faruzan(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_faruzan() 26 | scale_fill_faruzan(FALSE) 27 | scale_fill_faruzan(alpha = 0.5) 28 | scale_fill_faruzan(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_sucrose.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sucrose.r 3 | \name{scale_fill_sucrose} 4 | \alias{scale_fill_sucrose} 5 | \title{scale_fill_sucrose} 6 | \usage{ 7 | scale_fill_sucrose(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_sucrose() 26 | scale_fill_sucrose(FALSE) 27 | scale_fill_sucrose(alpha = 0.5) 28 | scale_fill_sucrose(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_yoimiya.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Yoimiya.r 3 | \name{scale_fill_yoimiya} 4 | \alias{scale_fill_yoimiya} 5 | \title{scale_fill_yoimiya} 6 | \usage{ 7 | scale_fill_yoimiya(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_yoimiya() 26 | scale_fill_yoimiya(FALSE) 27 | scale_fill_yoimiya(alpha = 0.5) 28 | scale_fill_yoimiya(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_zhongli.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Zhongli.r 3 | \name{scale_fill_zhongli} 4 | \alias{scale_fill_zhongli} 5 | \title{scale_fill_zhongli} 6 | \usage{ 7 | scale_fill_zhongli(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_zhongli() 26 | scale_fill_zhongli(FALSE) 27 | scale_fill_zhongli(alpha = 0.5) 28 | scale_fill_zhongli(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_ayaka.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ayaka.r 3 | \name{scale_colour_ayaka} 4 | \alias{scale_colour_ayaka} 5 | \title{scale_colour_ayaka} 6 | \usage{ 7 | scale_colour_ayaka(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_ayaka() 26 | scale_colour_ayaka(FALSE) 27 | scale_colour_ayaka(alpha = 0.5) 28 | scale_colour_ayaka(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_diona.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Diona.r 3 | \name{scale_colour_diona} 4 | \alias{scale_colour_diona} 5 | \title{scale_colour_diona} 6 | \usage{ 7 | scale_colour_diona(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_diona() 26 | scale_colour_diona(FALSE) 27 | scale_colour_diona(alpha = 0.5) 28 | scale_colour_diona(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_ganyu.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Ganyu.r 3 | \name{scale_colour_ganyu} 4 | \alias{scale_colour_ganyu} 5 | \title{scale_colour_ganyu} 6 | \usage{ 7 | scale_colour_ganyu(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_ganyu() 26 | scale_colour_ganyu(FALSE) 27 | scale_colour_ganyu(alpha = 0.5) 28 | scale_colour_ganyu(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_nilou.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nilou.r 3 | \name{scale_colour_nilou} 4 | \alias{scale_colour_nilou} 5 | \title{scale_colour_nilou} 6 | \usage{ 7 | scale_colour_nilou(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_nilou() 26 | scale_colour_nilou(FALSE) 27 | scale_colour_nilou(alpha = 0.5) 28 | scale_colour_nilou(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_razor.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Razor.r 3 | \name{scale_colour_razor} 4 | \alias{scale_colour_razor} 5 | \title{scale_colour_razor} 6 | \usage{ 7 | scale_colour_razor(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_razor() 26 | scale_colour_razor(FALSE) 27 | scale_colour_razor(alpha = 0.5) 28 | scale_colour_razor(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_venti.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Venti.r 3 | \name{scale_colour_venti} 4 | \alias{scale_colour_venti} 5 | \title{scale_colour_venti} 6 | \usage{ 7 | scale_colour_venti(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_venti() 26 | scale_colour_venti(FALSE) 27 | scale_colour_venti(alpha = 0.5) 28 | scale_colour_venti(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_bennett.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Bennett.r 3 | \name{scale_color_bennett} 4 | \alias{scale_color_bennett} 5 | \title{scale_color_bennett} 6 | \usage{ 7 | scale_color_bennett(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_bennett() 26 | scale_color_bennett(FALSE) 27 | scale_color_bennett(alpha = 0.5) 28 | scale_color_bennett(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_faruzan.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Faruzan.r 3 | \name{scale_color_faruzan} 4 | \alias{scale_color_faruzan} 5 | \title{scale_color_faruzan} 6 | \usage{ 7 | scale_color_faruzan(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_faruzan() 26 | scale_color_faruzan(FALSE) 27 | scale_color_faruzan(alpha = 0.5) 28 | scale_color_faruzan(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_sucrose.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sucrose.r 3 | \name{scale_color_sucrose} 4 | \alias{scale_color_sucrose} 5 | \title{scale_color_sucrose} 6 | \usage{ 7 | scale_color_sucrose(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_sucrose() 26 | scale_color_sucrose(FALSE) 27 | scale_color_sucrose(alpha = 0.5) 28 | scale_color_sucrose(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_yoimiya.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Yoimiya.r 3 | \name{scale_color_yoimiya} 4 | \alias{scale_color_yoimiya} 5 | \title{scale_color_yoimiya} 6 | \usage{ 7 | scale_color_yoimiya(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_yoimiya() 26 | scale_color_yoimiya(FALSE) 27 | scale_color_yoimiya(alpha = 0.5) 28 | scale_color_yoimiya(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_zhongli.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Zhongli.r 3 | \name{scale_color_zhongli} 4 | \alias{scale_color_zhongli} 5 | \title{scale_color_zhongli} 6 | \usage{ 7 | scale_color_zhongli(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_zhongli() 26 | scale_color_zhongli(FALSE) 27 | scale_color_zhongli(alpha = 0.5) 28 | scale_color_zhongli(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_tighnari.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tighnari.r 3 | \name{scale_fill_tighnari} 4 | \alias{scale_fill_tighnari} 5 | \title{scale_fill_tighnari} 6 | \usage{ 7 | scale_fill_tighnari(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_tighnari() 26 | scale_fill_tighnari(FALSE) 27 | scale_fill_tighnari(alpha = 0.5) 28 | scale_fill_tighnari(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_albedo.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Albedo.r 3 | \name{scale_colour_albedo} 4 | \alias{scale_colour_albedo} 5 | \title{scale_colour_albedo} 6 | \usage{ 7 | scale_colour_albedo(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_albedo() 26 | scale_colour_albedo(FALSE) 27 | scale_colour_albedo(alpha = 0.5) 28 | scale_colour_albedo(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_collei.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Collei.r 3 | \name{scale_colour_collei} 4 | \alias{scale_colour_collei} 5 | \title{scale_colour_collei} 6 | \usage{ 7 | scale_colour_collei(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_collei() 26 | scale_colour_collei(FALSE) 27 | scale_colour_collei(alpha = 0.5) 28 | scale_colour_collei(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_kazuha.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kazuha.r 3 | \name{scale_colour_kazuha} 4 | \alias{scale_colour_kazuha} 5 | \title{scale_colour_kazuha} 6 | \usage{ 7 | scale_colour_kazuha(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_kazuha() 26 | scale_colour_kazuha(FALSE) 27 | scale_colour_kazuha(alpha = 0.5) 28 | scale_colour_kazuha(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_keqing.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Keqing.r 3 | \name{scale_colour_keqing} 4 | \alias{scale_colour_keqing} 5 | \title{scale_colour_keqing} 6 | \usage{ 7 | scale_colour_keqing(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_keqing() 26 | scale_colour_keqing(FALSE) 27 | scale_colour_keqing(alpha = 0.5) 28 | scale_colour_keqing(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_kokomi.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Kokomi.r 3 | \name{scale_colour_kokomi} 4 | \alias{scale_colour_kokomi} 5 | \title{scale_colour_kokomi} 6 | \usage{ 7 | scale_colour_kokomi(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_kokomi() 26 | scale_colour_kokomi(FALSE) 27 | scale_colour_kokomi(alpha = 0.5) 28 | scale_colour_kokomi(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_nahida.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Nahida.r 3 | \name{scale_colour_nahida} 4 | \alias{scale_colour_nahida} 5 | \title{scale_colour_nahida} 6 | \usage{ 7 | scale_colour_nahida(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_nahida() 26 | scale_colour_nahida(FALSE) 27 | scale_colour_nahida(alpha = 0.5) 28 | scale_colour_nahida(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_noelle.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Noelle.r 3 | \name{scale_colour_noelle} 4 | \alias{scale_colour_noelle} 5 | \title{scale_colour_noelle} 6 | \usage{ 7 | scale_colour_noelle(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_noelle() 26 | scale_colour_noelle(FALSE) 27 | scale_colour_noelle(alpha = 0.5) 28 | scale_colour_noelle(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_shenhe.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shenhe.r 3 | \name{scale_colour_shenhe} 4 | \alias{scale_colour_shenhe} 5 | \title{scale_colour_shenhe} 6 | \usage{ 7 | scale_colour_shenhe(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_shenhe() 26 | scale_colour_shenhe(FALSE) 27 | scale_colour_shenhe(alpha = 0.5) 28 | scale_colour_shenhe(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_shogun.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Shogun.r 3 | \name{scale_colour_shogun} 4 | \alias{scale_colour_shogun} 5 | \title{scale_colour_shogun} 6 | \usage{ 7 | scale_colour_shogun(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_shogun() 26 | scale_colour_shogun(FALSE) 27 | scale_colour_shogun(alpha = 0.5) 28 | scale_colour_shogun(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_tighnari.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tighnari.r 3 | \name{scale_color_tighnari} 4 | \alias{scale_color_tighnari} 5 | \title{scale_color_tighnari} 6 | \usage{ 7 | scale_color_tighnari(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_tighnari() 26 | scale_color_tighnari(FALSE) 27 | scale_color_tighnari(alpha = 0.5) 28 | scale_color_tighnari(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_alhaitham.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Alhaitham.r 3 | \name{scale_fill_alhaitham} 4 | \alias{scale_fill_alhaitham} 5 | \title{scale_fill_alhaitham} 6 | \usage{ 7 | scale_fill_alhaitham(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_alhaitham() 26 | scale_fill_alhaitham(FALSE) 27 | scale_fill_alhaitham(alpha = 0.5) 28 | scale_fill_alhaitham(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_fill_xiangling.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiangling.r 3 | \name{scale_fill_xiangling} 4 | \alias{scale_fill_xiangling} 5 | \title{scale_fill_xiangling} 6 | \usage{ 7 | scale_fill_xiangling(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_fill_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_fill_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_fill_xiangling() 26 | scale_fill_xiangling(FALSE) 27 | scale_fill_xiangling(alpha = 0.5) 28 | scale_fill_xiangling(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_bennett.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Bennett.r 3 | \name{scale_colour_bennett} 4 | \alias{scale_colour_bennett} 5 | \title{scale_colour_bennett} 6 | \usage{ 7 | scale_colour_bennett(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_bennett() 26 | scale_colour_bennett(FALSE) 27 | scale_colour_bennett(alpha = 0.5) 28 | scale_colour_bennett(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_faruzan.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Faruzan.r 3 | \name{scale_colour_faruzan} 4 | \alias{scale_colour_faruzan} 5 | \title{scale_colour_faruzan} 6 | \usage{ 7 | scale_colour_faruzan(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_faruzan() 26 | scale_colour_faruzan(FALSE) 27 | scale_colour_faruzan(alpha = 0.5) 28 | scale_colour_faruzan(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_sucrose.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Sucrose.r 3 | \name{scale_colour_sucrose} 4 | \alias{scale_colour_sucrose} 5 | \title{scale_colour_sucrose} 6 | \usage{ 7 | scale_colour_sucrose(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_sucrose() 26 | scale_colour_sucrose(FALSE) 27 | scale_colour_sucrose(alpha = 0.5) 28 | scale_colour_sucrose(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_yoimiya.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Yoimiya.r 3 | \name{scale_colour_yoimiya} 4 | \alias{scale_colour_yoimiya} 5 | \title{scale_colour_yoimiya} 6 | \usage{ 7 | scale_colour_yoimiya(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_yoimiya() 26 | scale_colour_yoimiya(FALSE) 27 | scale_colour_yoimiya(alpha = 0.5) 28 | scale_colour_yoimiya(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_zhongli.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Zhongli.r 3 | \name{scale_colour_zhongli} 4 | \alias{scale_colour_zhongli} 5 | \title{scale_colour_zhongli} 6 | \usage{ 7 | scale_colour_zhongli(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_zhongli() 26 | scale_colour_zhongli(FALSE) 27 | scale_colour_zhongli(alpha = 0.5) 28 | scale_colour_zhongli(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_alhaitham.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Alhaitham.r 3 | \name{scale_color_alhaitham} 4 | \alias{scale_color_alhaitham} 5 | \title{scale_color_alhaitham} 6 | \usage{ 7 | scale_color_alhaitham(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_alhaitham() 26 | scale_color_alhaitham(FALSE) 27 | scale_color_alhaitham(alpha = 0.5) 28 | scale_color_alhaitham(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_color_xiangling.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiangling.r 3 | \name{scale_color_xiangling} 4 | \alias{scale_color_xiangling} 5 | \title{scale_color_xiangling} 6 | \usage{ 7 | scale_color_xiangling(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous color palette.} 11 | 12 | \item{alpha}{the alpha value of each color} 13 | 14 | \item{reverse}{invert the color sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot color scale 20 | } 21 | \description{ 22 | Mimicking the scale_color_XXX function, it returns a ggplot color scale 23 | } 24 | \examples{ 25 | scale_color_xiangling() 26 | scale_color_xiangling(FALSE) 27 | scale_color_xiangling(alpha = 0.5) 28 | scale_color_xiangling(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_tighnari.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Tighnari.r 3 | \name{scale_colour_tighnari} 4 | \alias{scale_colour_tighnari} 5 | \title{scale_colour_tighnari} 6 | \usage{ 7 | scale_colour_tighnari(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_tighnari() 26 | scale_colour_tighnari(FALSE) 27 | scale_colour_tighnari(alpha = 0.5) 28 | scale_colour_tighnari(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_alhaitham.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Alhaitham.r 3 | \name{scale_colour_alhaitham} 4 | \alias{scale_colour_alhaitham} 5 | \title{scale_colour_alhaitham} 6 | \usage{ 7 | scale_colour_alhaitham(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_alhaitham() 26 | scale_colour_alhaitham(FALSE) 27 | scale_colour_alhaitham(alpha = 0.5) 28 | scale_colour_alhaitham(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /man/scale_colour_xiangling.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/Xiangling.r 3 | \name{scale_colour_xiangling} 4 | \alias{scale_colour_xiangling} 5 | \title{scale_colour_xiangling} 6 | \usage{ 7 | scale_colour_xiangling(discrete = TRUE, alpha = 1, reverse = FALSE, ...) 8 | } 9 | \arguments{ 10 | \item{discrete}{if true, returns a discrete palette; if false, returns a continuous colour palette.} 11 | 12 | \item{alpha}{the alpha value of each colour} 13 | 14 | \item{reverse}{invert the colour sequence} 15 | 16 | \item{...}{passed to the discrete_scale or scale_color_gradientn} 17 | } 18 | \value{ 19 | a ggplot colour scale 20 | } 21 | \description{ 22 | Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 23 | } 24 | \examples{ 25 | scale_colour_xiangling() 26 | scale_colour_xiangling(FALSE) 27 | scale_colour_xiangling(alpha = 0.5) 28 | scale_colour_xiangling(FALSE, alpha = 0.7, reverse = TRUE) 29 | } 30 | -------------------------------------------------------------------------------- /R/keys.r: -------------------------------------------------------------------------------- 1 | #' keys 2 | #' 3 | #' returns the available key names, as well as the full names in both Chinese and English 4 | #' 5 | #' @return a data frame 6 | #' @export 7 | #' 8 | #' @examples 9 | #' keys() 10 | keys = function(){ 11 | key.name = c("albedo", 12 | "alhaitham", 13 | "ayaka", 14 | "bennett", 15 | "collei", 16 | "diona", 17 | "dori", 18 | "faruzan", 19 | "ganyu", 20 | "itto", 21 | "jean", 22 | "jin", 23 | "kazuha", 24 | "keqing", 25 | "klee", 26 | "kokomi", 27 | "miko", 28 | "nahida", 29 | "nilou", 30 | "noelle", 31 | "razor", 32 | "sayu", 33 | "shenhe", 34 | "shogun", 35 | "sucrose", 36 | "tao", 37 | "tighnari", 38 | "venti", 39 | "xiangling", 40 | "xiao", 41 | "yoimiya", 42 | "zhongli") 43 | en.fullname = c("Albedo", 44 | "Alhaitham", 45 | "Kamizato Ayaka", 46 | "Bennett", 47 | "Collei", 48 | "Diona", 49 | "Dori", 50 | "Faruzan", 51 | "Ganyu", 52 | "Arataki Itto", 53 | "Jean", 54 | "Yun Jin", 55 | "Kaedehara Kazuha", 56 | "Keqing", 57 | "Klee", 58 | "Sangonomiya Kokomi", 59 | "Yae Miko", 60 | "Nahida", 61 | "Nilou", 62 | "Noelle", 63 | "Razor", 64 | "Sayu", 65 | "Shenhe", 66 | "Raiden Shogun", 67 | "Sucrose", 68 | "Hu Tao", 69 | "Tighnari", 70 | "Venti", 71 | "Xiangling", 72 | "Xiao", 73 | "Yoimiya", 74 | "Zhongli") 75 | cn.fullname = c("\u963f\u8d1d\u591a", 76 | "\u827e\u5c14\u6d77\u68ee", 77 | "\u795e\u91cc\u7eeb\u534e", 78 | "\u73ed\u5c3c\u7279", 79 | "\u67ef\u83b1", 80 | "\u8fea\u5965\u5a1c", 81 | "\u591a\u8389", 82 | "\u73d0\u9732\u73ca", 83 | "\u7518\u96e8", 84 | "\u8352\u6cf7\u4e00\u6597", 85 | "\u7434", 86 | "\u4e91\u5807", 87 | "\u67ab\u539f\u4e07\u53f6", 88 | "\u523b\u6674", 89 | "\u53ef\u8389", 90 | "\u73ca\u745a\u5bab\u5fc3\u6d77", 91 | "\u516b\u91cd\u795e\u5b50", 92 | "\u7eb3\u897f\u59b2", 93 | "\u59ae\u9732", 94 | "\u8bfa\u827e\u5c14", 95 | "\u96f7\u6cfd", 96 | "\u65e9\u67da", 97 | "\u7533\u9e64", 98 | "\u96f7\u7535\u5c06\u519b", 99 | "\u7802\u7cd6", 100 | "\u80e1\u6843", 101 | "\u63d0\u7eb3\u91cc", 102 | "\u6e29\u8fea", 103 | "\u9999\u83f1", 104 | "\u9b48", 105 | "\u5bb5\u5bab", 106 | "\u949f\u79bb") 107 | return(data.frame(key.name, en.fullname, cn.fullname)) 108 | } 109 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # ggGenshin 2 | a collection of Genshin-styled color schemes 3 | 4 | ggGenshin is a package inspired by ggsci and content creator 阿昆的科研日常 of bilibili. The package provides a collection palettes in the style of Genshin and has both R (ggplot2) and Python (Matplotlib) interfaces. 5 | 6 | ## TODOs 7 | + Balanced palette: palettes better suited for heat map and feature plot etc. 8 | 9 | ## Installation 10 | ### R 11 | Paste the code to the R console to install ggGenshin from GitHub. 12 | 13 | ```R 14 | devtools::install_github("RestlessTail/ggGenshin") 15 | ``` 16 | 17 | ### Python 18 | Use pip to install ggGenshinPy from GitHub: 19 | 20 | ```shell 21 | pip install git+https://github.com/RestlessTail/ggGenshin@master-python 22 | ``` 23 | 24 | ## Usage 25 | ### R 26 | You can use `scale_color_XXX`/`scale_colour_XXX` or `scale_fill_XXX` to create a palette like in ggsci. But parameters can be somewhat different. 27 | 28 | ```R 29 | #p is a ggplot object 30 | print(p + scale_color_albedo()) 31 | print(p + scale_colour_albedo()) 32 | print(p + scale_fill_albedo()) 33 | ``` 34 | 35 | Each palette of ggGenshin has both discrete and continuous versions. ggGenshin returns a discrete palette by default. Use `discrete = FALSE` to create a continuous palette. 36 | 37 | ```R 38 | #p is a ggplot object 39 | print(p + scale_color_albedo(discrete = FALSE)) 40 | print(p + scale_colour_albedo(discrete = FALSE)) 41 | print(p + scale_fill_albedo(discrete = FALSE)) 42 | ``` 43 | 44 | `palette` is not available in ggGenshin. Use `alpha` to set transparency and use `reverse` to reverse the palette. 45 | 46 | ```R 47 | #p is a ggplot object 48 | print(p + scale_color_albedo(alpha = 0.8)) 49 | print(p + scale_colour_albedo(alpha = 0.8, reverse = TRUE)) 50 | print(p + scale_fill_albedo(alpha = 0.8)) 51 | print(p + scale_fill_albedo(alpha = 0.8, reverse = TRUE)) 52 | ``` 53 | 54 | `pal_XXX` and `rgb_XXX` are also available in ggGenshin. Use the two functions to export colors. 55 | 56 | ```R 57 | pal_albedo()(10) #create 10 colors 58 | pal_albedo(alpha = 0.5)(10) 59 | pal_albedo(alpha = 0.7, reverse = TRUE)(10) 60 | 61 | rgb_albedo(10) #create 10 colors 62 | rgb_albedo(n = 10, alpha = 0.5) 63 | rgb_albedo(n = 10, alpha = 0.7, reverse = TRUE) 64 | ``` 65 | 66 | Use `ggGenshin::keys()` for available palettes. 67 | 68 | ```R 69 | ggGenshin::keys() 70 | ``` 71 | 72 | ### Python 73 | Import `colormap` module of ggGenshinPy. 74 | 75 | ```python 76 | import ggGenshinPy.colormap as ggg 77 | ``` 78 | 79 | Use `cmapXXX` method to create a Matplotlib colormap object. ggGenshinPy returns a linear segmented colormap by default. Use `listed = True` to create a listed colormap. 80 | 81 | ```python 82 | # import Matplotlib 83 | import matplotlib.pyplot as plt 84 | 85 | # create a listed colormap 86 | plt.bar(range(4), range(1, 5), color = ggg.cmapSayu(listed = True)(range(4))) 87 | 88 | # create a linear segmented colormap 89 | heatmapDat = ([0.3, 1.5, 6.3, 5.3], [5.3, 9.6, 2.4, 6.7], [2.5, 7.6, 4.9, 4.3], [3.4, 9.0, 6.7, 0.6], [2.2, 5.3, 4.8, 9.8]) 90 | plt.imshow(heatmapDat, cmap = ggg.cmapYoimiya()) 91 | ``` 92 | 93 | Use `keys()` for available palettes. 94 | 95 | ```R 96 | ggg.keys() 97 | ``` 98 | 99 | -------------------------------------------------------------------------------- /R/Jin.r: -------------------------------------------------------------------------------- 1 | #' pal_jin 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_jin()(10) 15 | #' pal_jin(alpha = 0.5)(10) 16 | #' pal_jin(alpha = 0.5, reverse = TRUE)(20) 17 | pal_jin = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#1E1A22", "#4E4C72", "#67A4BA", "#D389A1", "#B94E5E") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_jin 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_jin() 49 | #' rgb_jin(10) 50 | #' rgb_jin(n = 10, alpha = 0.5) 51 | #' rgb_jin(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_jin = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_jin(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_jin 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_jin() 72 | #' scale_color_jin(FALSE) 73 | #' scale_color_jin(alpha = 0.5) 74 | #' scale_color_jin(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_jin = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "jin", pal_jin(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_jin(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_jin 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_jin() 98 | #' scale_colour_jin(FALSE) 99 | #' scale_colour_jin(alpha = 0.5) 100 | #' scale_colour_jin(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_jin = scale_color_jin 102 | 103 | #' scale_fill_jin 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_jin() 119 | #' scale_fill_jin(FALSE) 120 | #' scale_fill_jin(alpha = 0.5) 121 | #' scale_fill_jin(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_jin = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "jin", pal_jin(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_jin(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Tao.r: -------------------------------------------------------------------------------- 1 | #' pal_tao 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_tao()(10) 15 | #' pal_tao(alpha = 0.5)(10) 16 | #' pal_tao(alpha = 0.5, reverse = TRUE)(20) 17 | pal_tao = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#3A1B19", "#7B595E", "#C94737", "#C7A085", "#FCF0E1") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_tao 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_tao() 49 | #' rgb_tao(10) 50 | #' rgb_tao(n = 10, alpha = 0.5) 51 | #' rgb_tao(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_tao = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_tao(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_tao 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_tao() 72 | #' scale_color_tao(FALSE) 73 | #' scale_color_tao(alpha = 0.5) 74 | #' scale_color_tao(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_tao = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "tao", pal_tao(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_tao(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_tao 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_tao() 98 | #' scale_colour_tao(FALSE) 99 | #' scale_colour_tao(alpha = 0.5) 100 | #' scale_colour_tao(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_tao = scale_color_tao 102 | 103 | #' scale_fill_tao 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_tao() 119 | #' scale_fill_tao(FALSE) 120 | #' scale_fill_tao(alpha = 0.5) 121 | #' scale_fill_tao(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_tao = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "tao", pal_tao(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_tao(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Dori.r: -------------------------------------------------------------------------------- 1 | #' pal_dori 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_dori()(10) 15 | #' pal_dori(alpha = 0.5)(10) 16 | #' pal_dori(alpha = 0.5, reverse = TRUE)(20) 17 | pal_dori = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#291F27", "#705992", "#A97399", "#D68294", "#F3BFCA") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_dori 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_dori() 49 | #' rgb_dori(10) 50 | #' rgb_dori(n = 10, alpha = 0.5) 51 | #' rgb_dori(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_dori = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_dori(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_dori 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_dori() 72 | #' scale_color_dori(FALSE) 73 | #' scale_color_dori(alpha = 0.5) 74 | #' scale_color_dori(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_dori = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "dori", pal_dori(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_dori(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_dori 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_dori() 98 | #' scale_colour_dori(FALSE) 99 | #' scale_colour_dori(alpha = 0.5) 100 | #' scale_colour_dori(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_dori = scale_color_dori 102 | 103 | #' scale_fill_dori 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_dori() 119 | #' scale_fill_dori(FALSE) 120 | #' scale_fill_dori(alpha = 0.5) 121 | #' scale_fill_dori(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_dori = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "dori", pal_dori(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_dori(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Itto.r: -------------------------------------------------------------------------------- 1 | #' pal_itto 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_itto()(10) 15 | #' pal_itto(alpha = 0.5)(10) 16 | #' pal_itto(alpha = 0.5, reverse = TRUE)(20) 17 | pal_itto = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#211B1B", "#553766", "#D2CED2", "#F7DB78", "#8F402F") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_itto 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_itto() 49 | #' rgb_itto(10) 50 | #' rgb_itto(n = 10, alpha = 0.5) 51 | #' rgb_itto(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_itto = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_itto(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_itto 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_itto() 72 | #' scale_color_itto(FALSE) 73 | #' scale_color_itto(alpha = 0.5) 74 | #' scale_color_itto(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_itto = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "itto", pal_itto(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_itto(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_itto 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_itto() 98 | #' scale_colour_itto(FALSE) 99 | #' scale_colour_itto(alpha = 0.5) 100 | #' scale_colour_itto(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_itto = scale_color_itto 102 | 103 | #' scale_fill_itto 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_itto() 119 | #' scale_fill_itto(FALSE) 120 | #' scale_fill_itto(alpha = 0.5) 121 | #' scale_fill_itto(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_itto = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "itto", pal_itto(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_itto(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Jean.r: -------------------------------------------------------------------------------- 1 | #' pal_jean 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_jean()(10) 15 | #' pal_jean(alpha = 0.5)(10) 16 | #' pal_jean(alpha = 0.5, reverse = TRUE)(20) 17 | pal_jean = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#1D1B1C", "#224669", "#3E739E", "#E5E3E5", "#ECC9A3") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_jean 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_jean() 49 | #' rgb_jean(10) 50 | #' rgb_jean(n = 10, alpha = 0.5) 51 | #' rgb_jean(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_jean = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_jean(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_jean 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_jean() 72 | #' scale_color_jean(FALSE) 73 | #' scale_color_jean(alpha = 0.5) 74 | #' scale_color_jean(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_jean = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "jean", pal_jean(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_jean(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_jean 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_jean() 98 | #' scale_colour_jean(FALSE) 99 | #' scale_colour_jean(alpha = 0.5) 100 | #' scale_colour_jean(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_jean = scale_color_jean 102 | 103 | #' scale_fill_jean 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_jean() 119 | #' scale_fill_jean(FALSE) 120 | #' scale_fill_jean(alpha = 0.5) 121 | #' scale_fill_jean(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_jean = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "jean", pal_jean(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_jean(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Klee.r: -------------------------------------------------------------------------------- 1 | #' pal_klee 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_klee()(10) 15 | #' pal_klee(alpha = 0.5)(10) 16 | #' pal_klee(alpha = 0.5, reverse = TRUE)(20) 17 | pal_klee = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#421F1A", "#C1351D", "#875648", "#C08270", "#F6E1C6") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_klee 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_klee() 49 | #' rgb_klee(10) 50 | #' rgb_klee(n = 10, alpha = 0.5) 51 | #' rgb_klee(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_klee = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_klee(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_klee 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_klee() 72 | #' scale_color_klee(FALSE) 73 | #' scale_color_klee(alpha = 0.5) 74 | #' scale_color_klee(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_klee = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "klee", pal_klee(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_klee(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_klee 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_klee() 98 | #' scale_colour_klee(FALSE) 99 | #' scale_colour_klee(alpha = 0.5) 100 | #' scale_colour_klee(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_klee = scale_color_klee 102 | 103 | #' scale_fill_klee 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_klee() 119 | #' scale_fill_klee(FALSE) 120 | #' scale_fill_klee(alpha = 0.5) 121 | #' scale_fill_klee(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_klee = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "klee", pal_klee(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_klee(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Miko.r: -------------------------------------------------------------------------------- 1 | #' pal_miko 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_miko()(10) 15 | #' pal_miko(alpha = 0.5)(10) 16 | #' pal_miko(alpha = 0.5, reverse = TRUE)(20) 17 | pal_miko = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#362224", "#B24241", "#CB6E74", "#E8A9A6", "#DACECF") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_miko 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_miko() 49 | #' rgb_miko(10) 50 | #' rgb_miko(n = 10, alpha = 0.5) 51 | #' rgb_miko(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_miko = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_miko(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_miko 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_miko() 72 | #' scale_color_miko(FALSE) 73 | #' scale_color_miko(alpha = 0.5) 74 | #' scale_color_miko(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_miko = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "miko", pal_miko(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_miko(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_miko 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_miko() 98 | #' scale_colour_miko(FALSE) 99 | #' scale_colour_miko(alpha = 0.5) 100 | #' scale_colour_miko(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_miko = scale_color_miko 102 | 103 | #' scale_fill_miko 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_miko() 119 | #' scale_fill_miko(FALSE) 120 | #' scale_fill_miko(alpha = 0.5) 121 | #' scale_fill_miko(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_miko = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "miko", pal_miko(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_miko(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Sayu.r: -------------------------------------------------------------------------------- 1 | #' pal_sayu 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_sayu()(10) 15 | #' pal_sayu(alpha = 0.5)(10) 16 | #' pal_sayu(alpha = 0.5, reverse = TRUE)(20) 17 | pal_sayu = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#5B4A47", "#8C5D42", "#DA9464", "#F2D8AE", "#809A54") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_sayu 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_sayu() 49 | #' rgb_sayu(10) 50 | #' rgb_sayu(n = 10, alpha = 0.5) 51 | #' rgb_sayu(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_sayu = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_sayu(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_sayu 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_sayu() 72 | #' scale_color_sayu(FALSE) 73 | #' scale_color_sayu(alpha = 0.5) 74 | #' scale_color_sayu(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_sayu = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "sayu", pal_sayu(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_sayu(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_sayu 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_sayu() 98 | #' scale_colour_sayu(FALSE) 99 | #' scale_colour_sayu(alpha = 0.5) 100 | #' scale_colour_sayu(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_sayu = scale_color_sayu 102 | 103 | #' scale_fill_sayu 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_sayu() 119 | #' scale_fill_sayu(FALSE) 120 | #' scale_fill_sayu(alpha = 0.5) 121 | #' scale_fill_sayu(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_sayu = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "sayu", pal_sayu(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_sayu(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Xiao.r: -------------------------------------------------------------------------------- 1 | #' pal_xiao 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_xiao()(10) 15 | #' pal_xiao(alpha = 0.5)(10) 16 | #' pal_xiao(alpha = 0.5, reverse = TRUE)(20) 17 | pal_xiao = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#333C42", "#316658", "#5EA69C", "#C2CFA2", "#A4799E", "#706690") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_xiao 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_xiao() 49 | #' rgb_xiao(10) 50 | #' rgb_xiao(n = 10, alpha = 0.5) 51 | #' rgb_xiao(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_xiao = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_xiao(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_xiao 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_xiao() 72 | #' scale_color_xiao(FALSE) 73 | #' scale_color_xiao(alpha = 0.5) 74 | #' scale_color_xiao(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_xiao = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "xiao", pal_xiao(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_xiao(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_xiao 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_xiao() 98 | #' scale_colour_xiao(FALSE) 99 | #' scale_colour_xiao(alpha = 0.5) 100 | #' scale_colour_xiao(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_xiao = scale_color_xiao 102 | 103 | #' scale_fill_xiao 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_xiao() 119 | #' scale_fill_xiao(FALSE) 120 | #' scale_fill_xiao(alpha = 0.5) 121 | #' scale_fill_xiao(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_xiao = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "xiao", pal_xiao(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_xiao(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Ayaka.r: -------------------------------------------------------------------------------- 1 | #' pal_ayaka 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_ayaka()(10) 15 | #' pal_ayaka(alpha = 0.5)(10) 16 | #' pal_ayaka(alpha = 0.5, reverse = TRUE)(20) 17 | pal_ayaka = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#222449", "#414C87", "#9CB3D4", "#ECEDEB", "#AF5A76") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_ayaka 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_ayaka() 49 | #' rgb_ayaka(10) 50 | #' rgb_ayaka(n = 10, alpha = 0.5) 51 | #' rgb_ayaka(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_ayaka = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_ayaka(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_ayaka 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_ayaka() 72 | #' scale_color_ayaka(FALSE) 73 | #' scale_color_ayaka(alpha = 0.5) 74 | #' scale_color_ayaka(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_ayaka = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "ayaka", pal_ayaka(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_ayaka(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_ayaka 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_ayaka() 98 | #' scale_colour_ayaka(FALSE) 99 | #' scale_colour_ayaka(alpha = 0.5) 100 | #' scale_colour_ayaka(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_ayaka = scale_color_ayaka 102 | 103 | #' scale_fill_ayaka 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_ayaka() 119 | #' scale_fill_ayaka(FALSE) 120 | #' scale_fill_ayaka(alpha = 0.5) 121 | #' scale_fill_ayaka(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_ayaka = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "ayaka", pal_ayaka(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_ayaka(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Diona.r: -------------------------------------------------------------------------------- 1 | #' pal_diona 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_diona()(10) 15 | #' pal_diona(alpha = 0.5)(10) 16 | #' pal_diona(alpha = 0.5, reverse = TRUE)(20) 17 | pal_diona = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#393A53", "#DD9E5B", "#D58784", "#EDCAC6", "#B69480") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_diona 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_diona() 49 | #' rgb_diona(10) 50 | #' rgb_diona(n = 10, alpha = 0.5) 51 | #' rgb_diona(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_diona = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_diona(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_diona 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_diona() 72 | #' scale_color_diona(FALSE) 73 | #' scale_color_diona(alpha = 0.5) 74 | #' scale_color_diona(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_diona = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "diona", pal_diona(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_diona(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_diona 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_diona() 98 | #' scale_colour_diona(FALSE) 99 | #' scale_colour_diona(alpha = 0.5) 100 | #' scale_colour_diona(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_diona = scale_color_diona 102 | 103 | #' scale_fill_diona 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_diona() 119 | #' scale_fill_diona(FALSE) 120 | #' scale_fill_diona(alpha = 0.5) 121 | #' scale_fill_diona(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_diona = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "diona", pal_diona(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_diona(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | -------------------------------------------------------------------------------- /R/Ganyu.r: -------------------------------------------------------------------------------- 1 | #' pal_ganyu 2 | #' 3 | #' Mimicking the pal_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 4 | #' 5 | #' @param alpha the alpha value of each color 6 | #' @param reverse invert the color sequence 7 | #' 8 | #' @importFrom grDevices col2rgb rgb 9 | #' 10 | #' @return a vector of hexadecimal colors 11 | #' @export 12 | #' 13 | #' @examples 14 | #' pal_ganyu()(10) 15 | #' pal_ganyu(alpha = 0.5)(10) 16 | #' pal_ganyu(alpha = 0.5, reverse = TRUE)(20) 17 | pal_ganyu = function(alpha = 1, reverse = FALSE) { 18 | pal <- c("#33395B", "#5D74A2", "#C4D8F2", "#F2E8E3", "#7C282B") 19 | pal_rgb = col2rgb(pal) 20 | return(function(x){ 21 | vec = 1:x 22 | if(reverse){ 23 | vec = rev(vec) 24 | } 25 | return(sapply(vec, function(y){ 26 | len = length(pal) 27 | pos = y / x * len 28 | pos = ifelse(pos < 1, 1, ifelse(pos > len, len, pos)) 29 | rgb = pal_rgb[, floor(pos)] + (pal_rgb[, ceiling(pos)] - pal_rgb[, floor(pos)]) * (pos - floor(pos)) 30 | rgb = rgb / 255 31 | return(rgb(rgb[1], rgb[2], rgb[3], alpha)) 32 | })) 33 | }) 34 | } 35 | 36 | #' rgb_ganyu 37 | #' 38 | #' Mimicking the rgb_XXX function in the ggsci package, it returns a vector of hexadecimal colors. 39 | #' 40 | #' @param n the number of colors generated 41 | #' @param alpha the alpha value of each color 42 | #' @param reverse invert the color sequence 43 | #' 44 | #' @return a vector of hexadecimal colors 45 | #' @export 46 | #' 47 | #' @examples 48 | #' rgb_ganyu() 49 | #' rgb_ganyu(10) 50 | #' rgb_ganyu(n = 10, alpha = 0.5) 51 | #' rgb_ganyu(n = 20, alpha = 0.7, reverse = TRUE) 52 | rgb_ganyu = function(n = 12, alpha = 1, reverse = FALSE){ 53 | return(pal_ganyu(alpha = alpha, reverse = reverse)(n)) 54 | } 55 | 56 | #' scale_color_ganyu 57 | #' 58 | #' Mimicking the scale_color_XXX function, it returns a ggplot color scale 59 | #' 60 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 61 | #' @param alpha the alpha value of each color 62 | #' @param reverse invert the color sequence 63 | #' @param ... passed to the discrete_scale or scale_color_gradientn 64 | #' 65 | #' @importFrom ggplot2 discrete_scale scale_color_gradientn 66 | #' 67 | #' @return a ggplot color scale 68 | #' @export 69 | #' 70 | #' @examples 71 | #' scale_color_ganyu() 72 | #' scale_color_ganyu(FALSE) 73 | #' scale_color_ganyu(alpha = 0.5) 74 | #' scale_color_ganyu(FALSE, alpha = 0.7, reverse = TRUE) 75 | scale_color_ganyu = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 76 | if(discrete){ 77 | return(discrete_scale("colour", "ganyu", pal_ganyu(alpha = alpha, reverse = reverse), ...)) 78 | } 79 | else{ 80 | return(scale_color_gradientn(colours = rgb_ganyu(n = 512, alpha = alpha, reverse = reverse), ...)) 81 | } 82 | } 83 | 84 | #' scale_colour_ganyu 85 | #' 86 | #' Mimicking the scale_colour_XXX function, it returns a ggplot colour scale 87 | #' 88 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous colour palette. 89 | #' @param alpha the alpha value of each colour 90 | #' @param reverse invert the colour sequence 91 | #' @param ... passed to the discrete_scale or scale_color_gradientn 92 | #' 93 | #' @return a ggplot colour scale 94 | #' @export 95 | #' 96 | #' @examples 97 | #' scale_colour_ganyu() 98 | #' scale_colour_ganyu(FALSE) 99 | #' scale_colour_ganyu(alpha = 0.5) 100 | #' scale_colour_ganyu(FALSE, alpha = 0.7, reverse = TRUE) 101 | scale_colour_ganyu = scale_color_ganyu 102 | 103 | #' scale_fill_ganyu 104 | #' 105 | #' Mimicking the scale_fill_XXX function, it returns a ggplot color scale 106 | #' 107 | #' @param discrete if true, returns a discrete palette; if false, returns a continuous color palette. 108 | #' @param alpha the alpha value of each color 109 | #' @param reverse invert the color sequence 110 | #' @param ... passed to the discrete_scale or scale_fill_gradientn 111 | #' 112 | #' @importFrom ggplot2 discrete_scale scale_fill_gradientn 113 | #' 114 | #' @return a ggplot color scale 115 | #' @export 116 | #' 117 | #' @examples 118 | #' scale_fill_ganyu() 119 | #' scale_fill_ganyu(FALSE) 120 | #' scale_fill_ganyu(alpha = 0.5) 121 | #' scale_fill_ganyu(FALSE, alpha = 0.7, reverse = TRUE) 122 | scale_fill_ganyu = function(discrete = TRUE, alpha = 1, reverse = FALSE, ...) { 123 | if(discrete){ 124 | return(discrete_scale("fill", "ganyu", pal_ganyu(alpha = alpha, reverse = reverse), ...)) 125 | } 126 | else{ 127 | return(scale_fill_gradientn(colours = rgb_ganyu(n = 512, alpha = alpha, reverse = reverse), ...)) 128 | } 129 | } 130 | --------------------------------------------------------------------------------