staxriver
/
poker-analytics
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Work on aggregation type for evo graphs

Browse Source
feature/top10
Laurent 7 years ago
parent 8bbc35ba9a
commit 7447305caf
3 changed files with 310 additions and 197 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 70
      app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
  2. 141
      app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt
  3. 296
      app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt

70
app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt
Unescape View File

@ -7,7 +7,6 @@ import net.pokeranalytics.android.model.comparison.combined
import net.pokeranalytics.android.model.filter.QueryCondition
import net.pokeranalytics.android.model.filter.name
import net.pokeranalytics.android.model.realm.ComputableResult
import net.pokeranalytics.android.model.realm.Filter
import net.pokeranalytics.android.model.realm.SessionSet
import timber.log.Timber
import java.util.*
@ -20,7 +19,11 @@ class Calculator {
/**
* The options used for calculations or display
*/
class Options {
class Options(
display: Display = Display.TABLE,
evolutionValues: EvolutionValues = EvolutionValues.NONE,
stats: List<Stat> = listOf()
) {
/**
* The way the stats are going to be displayed
@ -42,9 +45,9 @@ class Calculator {
TIMED
}
var display: Display = Display.TABLE
var evolutionValues: EvolutionValues = EvolutionValues.NONE
var displayedStats: List<Stat> = listOf()
var display: Display = display
var evolutionValues: EvolutionValues = evolutionValues
var displayedStats: List<Stat> = stats
/**
* This function determines whether the standard deviation should be computed
@ -64,7 +67,36 @@ class Calculator {
companion object {
fun computeStatsWithComparators(realm: Realm, comparators: List<Comparator> = listOf(), conditions: List<QueryCondition> = listOf(), options: Options): Report {
fun computeStatsWithEvolutionByAggregationType(
realm: Realm,
group: ComputableGroup,
aggregationType: AggregationType
): Report {
val options = Options(evolutionValues = Options.EvolutionValues.STANDARD)
if (aggregationType == AggregationType.DURATION) {
options.evolutionValues = Options.EvolutionValues.TIMED
}
return when (aggregationType) {
AggregationType.SESSION, AggregationType.DURATION -> this.computeGroups(realm, listOf(group), options)
AggregationType.MONTH -> {
val comparators: List<Comparator> = listOf(Comparator.YEAR, Comparator.MONTH_OF_YEAR)
this.computeStatsWithComparators(realm, comparators, group.conditions, options)
}
AggregationType.YEAR -> {
val comparators: List<Comparator> = listOf(Comparator.YEAR)
this.computeStatsWithComparators(realm, comparators, group.conditions, options)
}
}
}
fun computeStatsWithComparators(
realm: Realm,
comparators: List<Comparator> = listOf(),
conditions: List<QueryCondition> = listOf(),
options: Options
): Report {
val computableGroups: MutableList<ComputableGroup> = mutableListOf()
comparators.combined().forEach { comparatorConditions ->
@ -86,18 +118,6 @@ class Calculator {
return this.computeGroups(realm, computableGroups, options)
}
fun computeStatsWithFilters(realm: Realm, filters: List<Filter>, options: Options): Report {
val computableGroups: MutableList<ComputableGroup> = mutableListOf()
filters.forEach { filter ->
val group = ComputableGroup(filter.name, filter.filterConditions.map { it.queryCondition })
computableGroups.add(group)
}
return Calculator.computeGroups(realm, computableGroups, options)
}
/**
* Computes all stats for list of Session sessionGroup
*/
@ -257,7 +277,12 @@ class Calculator {
Options.EvolutionValues.TIMED -> {
results.addEvolutionValue(tSum, tHourlyDuration, NETRESULT, sessionSet)
results.addEvolutionValue(tHourlyRate, tHourlyDuration, HOURLY_RATE, sessionSet)
results.addEvolutionValue(tIndex.toDouble(), tHourlyDuration, NUMBER_OF_SETS, sessionSet)
results.addEvolutionValue(
tIndex.toDouble(),
tHourlyDuration,
NUMBER_OF_SETS,
sessionSet
)
results.addEvolutionValue(
sessionSet.netDuration.toDouble(),
tHourlyDuration,
@ -273,7 +298,12 @@ class Calculator {
results.addEvolutionValue(tHourlyRateBB, tHourlyDuration, HOURLY_RATE_BB, sessionSet)
Stat.netBBPer100Hands(gBBSum, gTotalHands)?.let { netBB100 ->
results.addEvolutionValue(netBB100, tHourlyDuration, NET_BB_PER_100_HANDS, sessionSet)
results.addEvolutionValue(
netBB100,
tHourlyDuration,
NET_BB_PER_100_HANDS,
sessionSet
)
}
}
}

141
app/src/main/java/net/pokeranalytics/android/ui/fragment/GraphFragment.kt
Unescape View File

@ -13,7 +13,9 @@ import com.github.mikephil.charting.highlight.Highlight
import com.github.mikephil.charting.listener.OnChartValueSelectedListener
import com.google.android.material.chip.Chip
import com.google.android.material.chip.ChipGroup
import io.realm.Realm
import kotlinx.android.synthetic.main.fragment_evograph.*
import kotlinx.coroutines.*
import net.pokeranalytics.android.R
import net.pokeranalytics.android.calculus.*
import net.pokeranalytics.android.ui.activity.components.PokerAnalyticsActivity
@ -23,25 +25,32 @@ import net.pokeranalytics.android.ui.fragment.components.PokerAnalyticsFragment
import net.pokeranalytics.android.ui.graph.PALineDataSet
import net.pokeranalytics.android.ui.graph.setStyle
import net.pokeranalytics.android.ui.view.LegendView
import timber.log.Timber
import java.text.DateFormat
import java.util.*
import kotlin.coroutines.CoroutineContext
class GraphParameters(var stat: Stat, var report: Report) {
}
class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener, CoroutineScope {
private lateinit var parentActivity: PokerAnalyticsActivity
private var stat: Stat = Stat.NETRESULT
private var reports: Map<AggregationType, Report> = hashMapOf()
private var entries: List<Entry> = ArrayList()
private var reports: MutableMap<AggregationType, Report> = hashMapOf()
private var selectedReport: Report? = null
lateinit var legendView: LegendView
lateinit var chartView: BarLineChartBase<*>
private var aggregationTypes: List<AggregationType> = listOf()
override val coroutineContext: CoroutineContext
get() = Dispatchers.Main
companion object {
}
@ -50,10 +59,8 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
this.stat = stat
this.aggregationTypes = stat.aggregationTypes
// this.report = report
report.results.firstOrNull()?.defaultStatEntries(stat)?.let {
this.entries = it
}
this.reports[this.aggregationTypes.first()] = report
this.selectedReport = report
}
@ -76,32 +83,10 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
this.legendView = LegendView(requireContext())
this.legendContainer.addView(this.legendView)
this.legendView.prepareWithStat(this.stat, this.entries.size)
val dataSet = PALineDataSet(this.entries, this.stat.name, requireContext())
val colors = arrayOf(R.color.green_light).toIntArray()
dataSet.setColors(colors, context)
dataSet.setDrawCircles(false)
val lineData = LineData(listOf(dataSet))
this.chartView = when (stat.graphType) {
GraphType.LINE -> {
val lineChart = LineChart(context)
lineChart.data = lineData
lineChart
}
GraphType.BAR -> {
val barChart = BarChart(context)
barChart
}
}
this.chartContainer.addView(this.chartView)
this.chartView.setStyle(false, requireContext())
this.chartView.setOnChartValueSelectedListener(this)
this.chartView.highlightValue((this.entries.size - 1).toFloat(), 0)
this.selectedReport?.let {
this.loadGraph(it)
}
this.aggregationTypes.forEach { type ->
val chip = Chip(requireContext())
@ -118,12 +103,85 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
override fun onCheckedChanged(group: ChipGroup, checkedId: Int) {
super.onCheckedChanged(group, checkedId)
val aggregationType = aggregationTypes[checkedId]
// toast("Show: ${this.aggregationTypes[group.getChildAt(checkedId).id].name}")
reports[aggregationType]?.let {
loadGraph(it)
} ?: run {
}
}
})
}
private fun launchStatComputation() {
GlobalScope.launch(coroutineContext) {
var r: Report? = null
val test = GlobalScope.async {
val s = Date()
Timber.d(">>> start...")
val realm = Realm.getDefaultInstance()
val aggregationType = stat.aggregationTypes.first()
// r = Calculator.computeStatsWithEvolutionByAggregationType(realm, computableGroup, aggregationType)
realm.close()
val e = Date()
val duration = (e.time - s.time) / 1000.0
Timber.d(">>> ended in $duration seconds")
}
test.await()
if (!isDetached) {
r?.let {
loadGraph(it)
}
}
}
}
fun loadGraph(report: Report) {
report.results.firstOrNull()?.defaultStatEntries(stat)?.let { entries ->
this.legendView.prepareWithStat(this.stat, entries.size)
val dataSet = PALineDataSet(entries, this.stat.name, requireContext())
val colors = arrayOf(R.color.green_light).toIntArray()
dataSet.setColors(colors, context)
dataSet.setDrawCircles(false)
val lineData = LineData(listOf(dataSet))
this.chartView = when (stat.graphType) {
GraphType.LINE -> {
val lineChart = LineChart(context)
lineChart.data = lineData
lineChart
}
GraphType.BAR -> {
val barChart = BarChart(context)
barChart
}
}
this.chartContainer.addView(this.chartView)
this.chartView.setStyle(false, requireContext())
this.chartView.setOnChartValueSelectedListener(this)
this.chartView.highlightValue((entries.size - 1).toFloat(), 0)
}
}
// OnChartValueSelectedListener
override fun onNothingSelected() {
@ -133,19 +191,18 @@ class GraphFragment : PokerAnalyticsFragment(), OnChartValueSelectedListener {
override fun onValueSelected(e: Entry?, h: Highlight?) {
e?.let { entry ->
h?.let { highlight ->
val identifier = entry.data as ObjectIdentifier
val item = getRealm().where(identifier.clazz).equalTo("id", identifier.id).findAll().firstOrNull()
item?.let {
val identifier = entry.data as ObjectIdentifier
val item = getRealm().where(identifier.clazz).equalTo("id", identifier.id).findAll().firstOrNull()
item?.let {
val formattedDate = DateFormat.getDateInstance(DateFormat.SHORT).format(it.startDate())
val entryValue = it.formattedValue(this.stat, requireContext())
val totalStatValue = this.stat.format(e.y.toDouble(), null, requireContext())
val formattedDate = DateFormat.getDateInstance(DateFormat.SHORT).format(it.startDate())
val entryValue = it.formattedValue(this.stat, requireContext())
val totalStatValue = this.stat.format(e.y.toDouble(), null, requireContext())
this.legendView.setItemData(this.stat, formattedDate, entryValue, totalStatValue)
}
this.legendView.setItemData(this.stat, formattedDate, entryValue, totalStatValue)
}
}
}

296
app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt
Unescape View File

@ -28,96 +28,96 @@ import kotlin.coroutines.CoroutineContext
class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSource, CoroutineScope,
RowRepresentableDelegate {
override val coroutineContext: CoroutineContext
get() = Dispatchers.Main
override val coroutineContext: CoroutineContext
get() = Dispatchers.Main
private var rowRepresentables: ArrayList<RowRepresentable> = ArrayList()
private var rowRepresentables: ArrayList<RowRepresentable> = ArrayList()
private var stringAll = ""
private var stringCashGame = ""
private var stringTournament = ""
private lateinit var statsAdapter: RowRepresentableAdapter
private var report : Report? = null
companion object {
/**
* Create new instance
*/
fun newInstance(): StatsFragment {
val fragment = StatsFragment()
val bundle = Bundle()
fragment.arguments = bundle
return fragment
}
}
// Life Cycle
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
return inflater.inflate(R.layout.fragment_stats, container, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
initData()
initUI()
launchStatComputation()
}
// Row Representable DS
override fun adapterRows(): List<RowRepresentable>? {
return this.rowRepresentables
}
override fun contentDescriptorForRow(row: RowRepresentable): DisplayDescriptor? {
val dc = DisplayDescriptor()
dc.textFormat = TextFormat(NULL_TEXT)
if (row is StatRepresentable) {
context?.let { context ->
row.computedStat?.let {
dc.textFormat = it.format(context)
}
}
}
return dc
}
override fun statFormatForRow(row: RowRepresentable): TextFormat {
if (row is StatRepresentable) {
context?.let { context ->
row.computedStat?.let { return it.format(context) }
}
}
return TextFormat(NULL_TEXT)
}
override fun onResume() {
super.onResume()
statsAdapter.notifyDataSetChanged()
}
// Override
override fun sessionsChanged() {
this.launchStatComputation()
this.statsAdapter.notifyDataSetChanged()
}
// Business
/**
* Init data
*/
private fun initData() {
this.stringAll = getString(R.string.all)
this.stringCashGame = getString(R.string.cash_game)
this.stringTournament = getString(R.string.tournament)
this.statsAdapter = RowRepresentableAdapter(this, this)
}
private lateinit var statsAdapter: RowRepresentableAdapter
private var report: Report? = null
companion object {
/**
* Create new instance
*/
fun newInstance(): StatsFragment {
val fragment = StatsFragment()
val bundle = Bundle()
fragment.arguments = bundle
return fragment
}
}
// Life Cycle
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
return inflater.inflate(R.layout.fragment_stats, container, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
initData()
initUI()
launchStatComputation()
}
// Row Representable DS
override fun adapterRows(): List<RowRepresentable>? {
return this.rowRepresentables
}
override fun contentDescriptorForRow(row: RowRepresentable): DisplayDescriptor? {
val dc = DisplayDescriptor()
dc.textFormat = TextFormat(NULL_TEXT)
if (row is StatRepresentable) {
context?.let { context ->
row.computedStat?.let {
dc.textFormat = it.format(context)
}
}
}
return dc
}
override fun statFormatForRow(row: RowRepresentable): TextFormat {
if (row is StatRepresentable) {
context?.let { context ->
row.computedStat?.let { return it.format(context) }
}
}
return TextFormat(NULL_TEXT)
}
override fun onResume() {
super.onResume()
statsAdapter.notifyDataSetChanged()
}
// Override
override fun sessionsChanged() {
this.launchStatComputation()
this.statsAdapter.notifyDataSetChanged()
}
// Business
/**
* Init data
*/
private fun initData() {
this.stringAll = getString(R.string.all)
this.stringCashGame = getString(R.string.cash_game)
this.stringTournament = getString(R.string.tournament)
this.statsAdapter = RowRepresentableAdapter(this, this)
}
/**
* Init UI
@ -133,67 +133,89 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
}
}
private fun launchStatComputation() {
private fun launchStatComputation() {
GlobalScope.launch(coroutineContext) {
var r = Report()
val test = GlobalScope.async {
val s = Date()
Timber.d(">>> start...")
val realm = Realm.getDefaultInstance()
r = createSessionGroupsAndStartCompute(realm)
report = r
realm.close()
val e = Date()
val duration = (e.time - s.time) / 1000.0
Timber.d(">>> ended in $duration seconds")
GlobalScope.launch(coroutineContext) {
}
test.await()
var r = Report()
val test = GlobalScope.async {
val s = Date()
Timber.d(">>> start...")
if (!isDetached) {
showResults(r)
}
}
val realm = Realm.getDefaultInstance()
r = createSessionGroupsAndStartCompute(realm)
report = r
realm.close()
}
val e = Date()
val duration = (e.time - s.time) / 1000.0
Timber.d(">>> ended in $duration seconds")
private fun createSessionGroupsAndStartCompute(realm: Realm) : Report {
}
test.await()
val allStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE, Stat.NUMBER_OF_SETS, Stat.AVERAGE_DURATION, Stat.DURATION)
val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats)
val cgStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.NET_BB_PER_100_HANDS, Stat.HOURLY_RATE_BB, Stat.AVERAGE, Stat.STANDARD_DEVIATION_HOURLY, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.CASH), cgStats)
val tStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
val tSessionGroup = ComputableGroup(stringTournament, listOf(QueryCondition.TOURNAMENT), tStats)
if (!isDetached) {
showResults(r)
}
}
Timber.d(">>>>> Start computations...")
}
return Calculator.computeGroups(realm, listOf(allSessionGroup, cgSessionGroup, tSessionGroup), Calculator.Options())
private fun createSessionGroupsAndStartCompute(realm: Realm): Report {
val allStats: List<Stat> = listOf(
Stat.NETRESULT,
Stat.HOURLY_RATE,
Stat.AVERAGE,
Stat.NUMBER_OF_SETS,
Stat.AVERAGE_DURATION,
Stat.DURATION
)
val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats)
val cgStats: List<Stat> = listOf(
Stat.NETRESULT,
Stat.HOURLY_RATE,
Stat.NET_BB_PER_100_HANDS,
Stat.HOURLY_RATE_BB,
Stat.AVERAGE,
Stat.STANDARD_DEVIATION_HOURLY,
Stat.WIN_RATIO,
Stat.NUMBER_OF_GAMES,
Stat.AVERAGE_BUYIN
)
val cgSessionGroup = ComputableGroup(stringCashGame, listOf(QueryCondition.CASH), cgStats)
val tStats: List<Stat> =
listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.ROI, Stat.WIN_RATIO, Stat.NUMBER_OF_GAMES, Stat.AVERAGE_BUYIN)
val tSessionGroup = ComputableGroup(stringTournament, listOf(QueryCondition.TOURNAMENT), tStats)
Timber.d(">>>>> Start computations...")
return Calculator.computeGroups(
realm,
listOf(allSessionGroup, cgSessionGroup, tSessionGroup),
Calculator.Options()
)
}
}
private fun showResults(report: Report) {
this.rowRepresentables = this.convertReportIntoRepresentables(report)
private fun showResults(report: Report) {
this.rowRepresentables = this.convertReportIntoRepresentables(report)
statsAdapter.notifyDataSetChanged()
}
}
private fun convertReportIntoRepresentables(report: Report) : ArrayList<RowRepresentable> {
private fun convertReportIntoRepresentables(report: Report): ArrayList<RowRepresentable> {
val rows: ArrayList<RowRepresentable> = ArrayList()
val rows: ArrayList<RowRepresentable> = ArrayList()
report.results.forEach { result ->
rows.add(CustomizableRowRepresentable(title = result.group.name))
result.group.stats?.forEach { stat ->
rows.add(StatRepresentable(stat, result.computedStat(stat), result.group.name))
}
}
report.results.forEach { result ->
rows.add(CustomizableRowRepresentable(title = result.group.name))
result.group.stats?.forEach { stat ->
rows.add(StatRepresentable(stat, result.computedStat(stat), result.group.name))
}
}
return rows
}
return rows
}
// RowRepresentableDelegate
@ -223,10 +245,14 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
Timber.d(">>> start...")
val realm = Realm.getDefaultInstance()
val options = Calculator.Options()
options.evolutionValues = Calculator.Options.EvolutionValues.STANDARD
options.displayedStats = listOf(stat)
report = Calculator.computeGroups(realm, listOf(computableGroup), options)
// val options = Calculator.Options()
// options.evolutionValues = Calculator.Options.EvolutionValues.STANDARD
// options.displayedStats = listOf(stat)
val aggregationType = stat.aggregationTypes.first()
report = Calculator.computeStatsWithEvolutionByAggregationType(realm, computableGroup, aggregationType)
// report = Calculator.computeGroups(realm, listOf(computableGroup), options)
realm.close()
val e = Date()

Write Preview
Loading…
Cancel
Save