## Insect Counter

Hello world! For my research on scavenging guilds in the Australian Alps, I tallied nearly 30,000 insects. To do so, I made a quick web-based tool that I could quickly tally what I found. Its easy to use including features to copy the tally in a table format to paste into MS Excel.

I know this is a tool taylored specifically for my project, but I think its functionality can be applied for others out there.

## Australia’s wimpy vertebrate scavenger guild

Australia lacks a robust vertebrate scavenger guild which allows insects to outcompete them at carrion. Insects are the primary decomposers in the Australian Alps

## Project Map

Hello world!

I’d like to share some maps I’ve made of my master’s project. I’ve conducted an ecological project looking at scavenging dynamics in the Australian Alps, specifically in Kosciuszko National Park in New South Wales. The maps show the Australian Alps (the highest region in mainland Australia) and my autumn replicate transect. The transect runs along Island Bend Fire Trail and Guthega road. Each site is roughly 1km distance from each other with treatments approximately 50m from one another.

Each site consists of three treatments 1) Open / No Exclusion, 2) Vertebrate Exclusion, and 3) Vertebrate + Insect Exclusion.

These maps were produced with QGIS version 3.2+.

## Permutation Pyramid

OK so here’s an update to the permutation pyramid I made.

I had to make a list of different permutations of models but it became hard to keep track of all the different variables and their combinations. Hence, the permutation pyramid. The goal is to make a list of vector combinations and permutations. I found this super useful when generating formulas for AICc/Model selection.

Enjoy!

The function has a few options:

1. vec
• The vector to draw the combinations/permutations from
2. order.matters = FALSE
• A simple boolean TRUE / FALSE to add in the permutations of each vector combination. This will generate permutations of the combinations and add them to the list. This may only be useful for certain models
3. req
• A vector of elements that should be required in the combinations.
4. interact
• A list of vector combinations that can be found in the original combinations

## Function

```pyramid <- function( vec, order.matters = FALSE, req, interact ){
# pyramid of variable combinations
# this doesn't include different
# arrangements
vrz <- lapply(
1:length( vec ),
function( x ){
combn( vec, x ) %>% as.data.frame()
}
) %>% purrr::flatten() %>% unname()

# If there are interactions
if( !missing( interact ) ){
# possible interaction combos
intx <- seq( from = 1, to = length( interact ), by = 1 ) %>% knp.perm.pyramid()

# extra interactions
vrz.int <- list()

# look through vars
for( v in vrz ){

# make a list of interactions
# and add them to the list
vrz.int <- append(
vrz.int,
lapply( intx, function( ints ){
# count number of matches to compare
# and filter out unaltered var lists
mt <- 0

# for each interaction
# check if its in the array
# then add it if it is
for ( int in ints ) {
if(
length( intersect( v, interact[[ int ]] ) ) == length( interact[[ int ]] ) &
length( interact[[ int ]] ) > 1
){
v <- c( v, paste0( interact[[ int ]], collapse = ":" ) )
mt <- mt + 1
}
}

# if the number of matches equals
# the number of interactions then
# return the altered array
if( mt == length(ints) ){
return( v )
}
return( NULL )

}) %>% plyr::compact()
)
}

# append interactions
vrz <- append( vrz, vrz.int )
}

# order matters so lets rearrange
if( order.matters ){
vrz <- lapply( vrz, function( x ){
combinat::permn( x )
}) %>% purrr::flatten()
}

# if there's any required variables in each combination
if( !missing( req ) ){
vrz <- lapply(vrz, function( x ){
if( length( intersect( x, req ) ) == length( req ) ){
return( x )
}
return( NULL )
}) %>% plyr::compact()
}

# return list of character
# permutations
return( vrz )
}
```

## Examples / Usage

Plain vanilla use

```> a <- c( "A", "B", "C" )
> pyramid( a )
[]
 "A"

[]
 "B"

[]
 "C"

[]
 "A" "B"

[]
 "A" "C"

[]
 "B" "C"

[]
 "A" "B" "C"
```

If the order of the elements matters

```> a <- c( "A", "B", "C" )
> pyramid( a, order.matters = TRUE )
[]
 "A"

[]
 "B"

[]
 "C"

[]
 "A" "B"

[]
 "B" "A"

[]
 "A" "C"

[]
 "C" "A"

[]
 "B" "C"

[]
 "C" "B"

[]
 "A" "B" "C"

[]
 "A" "C" "B"

[]
 "C" "A" "B"

[]
 "C" "B" "A"

[]
 "B" "C" "A"

[]
 "B" "A" "C"
```

Require variables

```> a <- c( "A", "B", "C", "D", "E" )
> b <- c( "B", "D" )
> pyramid( a, req = b )
[]
 "B" "D"

[]
 "A" "B" "D"

[]
 "B" "C" "D"

[]
 "B" "D" "E"

[]
 "A" "B" "C" "D"

[]
 "A" "B" "D" "E"

[]
 "B" "C" "D" "E"

[]
 "A" "B" "C" "D" "E"
```

Include interactions

```> a <- c( "A", "B", "C")
> b <- list( c( "A", "B" ), c( "A", "B", "C" ) )
> pyramid( a, interact = b )
[]
 "A"

[]
 "B"

[]
 "C"

[]
 "A" "B"

[]
 "A" "C"

[]
 "B" "C"

[]
 "A" "B" "C"

[]
 "A"   "B"   "A:B"

[]
 "A"   "B"   "C"   "A:B"

[]
 "A"     "B"     "C"     "A:B:C"

[]
 "A"     "B"     "C"     "A:B"   "A:B:C"
```

## Permutation Pyramid

So I had to make a combination of different values based on elements in a vector. With a few tweaks and what not I made a little function to find all the combinations and permutations of a given vector. Enjoy

The function:

```# creat a list of combinations and
# permutations of elements from
# a single vector. This requires
# a few libraries:
# library( dplyr )
# library( purrr )
# library( combinat )

# "order.matters" is means that
# for every combination of elements
# find every order they can be
# arranged.

permutation.pyramid <- function( v, order.matters = TRUE ){

# get the unique combinations of elements
# and flatten them into a one dimensional list
out <- 1:length(v) %>%
lapply(function( x ){
combn( v, x ) %>% as.data.frame()
}) %>%
purrr::flatten() %>%
unname()

# if order.matters then find all the
# arrangements of each combination
if( order.matters ){
out <- out %>%
lapply(function( x ){
combinat::permn( x )
}) %>%
purrr::flatten()
}

# return list of permutations
return( out )
}

```

Use and examples.

Find all combinations and permutations of a given vector

```> test <- c("A","B","C")
> permutation.pyramid( test )
[]
 "A"

[]
 "B"

[]
 "C"

[]
 "A" "B"

[]
 "B" "A"

[]
 "A" "C"

[]
 "C" "A"

[]
 "B" "C"

[]
 "C" "B"

[]
 "A" "B" "C"

[]
 "A" "C" "B"

[]
 "C" "A" "B"

[]
 "C" "B" "A"

[]
 "B" "C" "A"

[]
 "B" "A" "C"
```

Find all combinations of vector

```> test <- c("A","B","C")
> permutation.pyramid( test, order.matters = FALSE )
[]
 "A"

[]
 "B"

[]
 "C"

[]
 "A" "B"

[]
 "A" "C"

[]
 "B" "C"

[]
 "A" "B" "C"
```

Anyways I hope that’ll be useful for someone!

## Confidence Intervals

A small little function written in R to get the 95% confidence intervals and some quick stats of a vector. I found this useful in error reporting in some stats. I got the concept from this tutorial.

This does require the dplyr library

Function

```library( dplyr )

ci <- function( x ){
cnf <- dplyr::tibble(
mean = mean( x, na.rm = TRUE),
st.dev = sd( x, na.rm = TRUE),
n = length( x ),
error = qnorm( 0.975 ) * st.dev / sqrt( n ),
ci05 = mean - error,
ci95 = mean + error
)

cat( cnf\$mean, "(", cnf\$ci05, "-", cnf\$ci95, ")\n" )
return( cnf )
}
```

Use

```> x <- sample(10)
> ci(x)
5.5 ( 3.623477 - 7.376523 )
# A tibble: 1 x 6
mean st.dev     n error  ci05  ci95
<dbl>  <dbl> <int> <dbl> <dbl> <dbl>
1   5.5   3.03    10  1.88  3.62  7.38
```

## Updates to Research into Chaos

Just a quick update on how pretty I got these cards to look! Check it out!.

## Quick update to Grade Calculator

Just a quick update to make the Grade Calculator more user friendly.

1. Added a very simple notification system for the overall grade. It’ll now tell you if you pass a certain grade threshold for the overall mark. Default is 50% for all the Aussie grading system

Hope y’all can enjoy that and find it useful.

## Sn-Emus!

Record snowfall in the Snowies and these fellas are loving it! Benefits of data collection in Kosciuszko

## Sorting Trail Camera Images for DigiKam

So DigiKam is a very useful tool to manage collections of images particularly from remote sensing wildlife cameras such as the Reconyx Hyperfire. However this program wasn’t made specifically for these game cameras so for the moment it’s lacking direct capability to sort between some of the motion triggered vs time lapse images. Luckily I’ve found a way around this and get back to sorting data in DigiKam.

Although Reconyx cameras use an exif readable tag in their images, DigiKam only reads a specific subset of that so the TriggerMode tag is left out. However, DigiKam does read the caption tag so my methodology is:

1. Conditionally set the caption tag to “Time Lapse” if the TriggerMode tag equals “Time Lapse”. This will skip putting the caption on motion triggered.
```exiftool -r -Caption="Time Lapse"